refactor: rename the atom directory to shell

shell/renderer/api/atom_api_renderer_ipc.cc

@@ -0,0 +1,203 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include <string>
+
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_bindings.h"
+#include "atom/common/node_includes.h"
+#include "atom/common/promise_util.h"
+#include "base/task/post_task.h"
+#include "base/values.h"
+#include "content/public/renderer/render_frame.h"
+#include "electron/atom/common/api/api.mojom.h"
+#include "native_mate/arguments.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/handle.h"
+#include "native_mate/object_template_builder.h"
+#include "native_mate/wrappable.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
+#include "third_party/blink/public/web/web_local_frame.h"
+
+using blink::WebLocalFrame;
+using content::RenderFrame;
+
+namespace {
+
+RenderFrame* GetCurrentRenderFrame() {
+  WebLocalFrame* frame = WebLocalFrame::FrameForCurrentContext();
+  if (!frame)
+    return nullptr;
+
+  return RenderFrame::FromWebFrame(frame);
+}
+
+class IPCRenderer : public mate::Wrappable<IPCRenderer> {
+ public:
+  explicit IPCRenderer(v8::Isolate* isolate)
+      : task_runner_(base::CreateSingleThreadTaskRunnerWithTraits({})) {
+    Init(isolate);
+    RenderFrame* render_frame = GetCurrentRenderFrame();
+    DCHECK(render_frame);
+
+    // Bind the interface on the background runner. All accesses will be via
+    // the thread-safe pointer. This is to support our "fake-sync"
+    // MessageSync() hack; see the comment in IPCRenderer::SendSync.
+    atom::mojom::ElectronBrowserPtrInfo info;
+    render_frame->GetRemoteInterfaces()->GetInterface(mojo::MakeRequest(&info));
+    electron_browser_ptr_ = atom::mojom::ThreadSafeElectronBrowserPtr::Create(
+        std::move(info), task_runner_);
+  }
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::FunctionTemplate> prototype) {
+    prototype->SetClassName(mate::StringToV8(isolate, "IPCRenderer"));
+    mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+        .SetMethod("send", &IPCRenderer::Send)
+        .SetMethod("sendSync", &IPCRenderer::SendSync)
+        .SetMethod("sendTo", &IPCRenderer::SendTo)
+        .SetMethod("sendToHost", &IPCRenderer::SendToHost)
+        .SetMethod("invoke", &IPCRenderer::Invoke);
+  }
+
+  static mate::Handle<IPCRenderer> Create(v8::Isolate* isolate) {
+    return mate::CreateHandle(isolate, new IPCRenderer(isolate));
+  }
+
+  void Send(bool internal,
+            const std::string& channel,
+            const base::ListValue& arguments) {
+    electron_browser_ptr_->get()->Message(internal, channel, arguments.Clone());
+  }
+
+  v8::Local<v8::Promise> Invoke(mate::Arguments* args,
+                                const std::string& channel,
+                                const base::Value& arguments) {
+    atom::util::Promise p(args->isolate());
+    auto handle = p.GetHandle();
+
+    electron_browser_ptr_->get()->Invoke(
+        channel, arguments.Clone(),
+        base::BindOnce([](atom::util::Promise p,
+                          base::Value result) { p.Resolve(result); },
+                       std::move(p)));
+
+    return handle;
+  }
+
+  void SendTo(bool internal,
+              bool send_to_all,
+              int32_t web_contents_id,
+              const std::string& channel,
+              const base::ListValue& arguments) {
+    electron_browser_ptr_->get()->MessageTo(
+        internal, send_to_all, web_contents_id, channel, arguments.Clone());
+  }
+
+  void SendToHost(const std::string& channel,
+                  const base::ListValue& arguments) {
+    electron_browser_ptr_->get()->MessageHost(channel, arguments.Clone());
+  }
+
+  base::Value SendSync(bool internal,
+                       const std::string& channel,
+                       const base::ListValue& arguments) {
+    // We aren't using a true synchronous mojo call here. We're calling an
+    // asynchronous method and blocking on the result. The reason we're doing
+    // this is a little complicated, so buckle up.
+    //
+    // Mojo has a concept of synchronous calls. However, synchronous calls are
+    // dangerous. In particular, it's quite possible for two processes to call
+    // synchronous methods on each other and cause a deadlock. Mojo has a
+    // mechanism to avoid this kind of deadlock: if a process is waiting on the
+    // result of a synchronous call, and it receives an incoming call for a
+    // synchronous method, it will process that request immediately, even
+    // though it's currently blocking. However, if it receives an incoming
+    // request for an _asynchronous_ method, that can't cause a deadlock, so it
+    // stashes the request on a queue to be processed once the synchronous
+    // thing it's waiting on returns.
+    //
+    // This behavior is useful for preventing deadlocks, but it is inconvenient
+    // here because it can result in messages being reordered. If the main
+    // process is awaiting the result of a synchronous call (which it does only
+    // very rarely, since it's bad to block the main process), and we send
+    // first an asynchronous message to the main process, followed by a
+    // synchronous message, then the main process will process the synchronous
+    // one first.
+    //
+    // It turns out, Electron has some dependency on message ordering,
+    // especially during window shutdown, and getting messages out of order can
+    // result in, for example, remote objects disappearing unexpectedly. To
+    // avoid these issues and guarantee consistent message ordering, we send
+    // all messages to the main process as asynchronous messages. This causes
+    // them to always be queued and processed in the same order they were
+    // received, even if they were received while the main process was waiting
+    // on a synchronous call.
+    //
+    // However, in the calling process, we still need to block on the result,
+    // because the caller is expecting a result synchronously. So we do a bit
+    // of a trick: we pass the Mojo handle over to a worker thread, send the
+    // asynchronous message from that thread, and then block on the result.
+    // It's important that we pass the handle over to the worker thread,
+    // because that allows Mojo to process incoming messages (most importantly,
+    // the response to our request) on that thread. If we didn't pass it to a
+    // worker thread, and instead sent the call from the main thread, we would
+    // never receive a response because Mojo wouldn't be able to run its
+    // message handling code, because the main thread would be tied up blocking
+    // on the WaitableEvent.
+    //
+    // Phew. If you got this far, here's a gold star: ⭐️
+
+    base::Value result;
+
+    // A task is posted to a worker thread to execute the request so that
+    // this thread may block on a waitable event. It is safe to pass raw
+    // pointers to |result| and |response_received_event| as this stack frame
+    // will survive until the request is complete.
+
+    base::WaitableEvent response_received_event;
+    task_runner_->PostTask(
+        FROM_HERE, base::BindOnce(&IPCRenderer::SendMessageSyncOnWorkerThread,
+                                  base::Unretained(this),
+                                  base::Unretained(&response_received_event),
+                                  base::Unretained(&result), internal, channel,
+                                  arguments.Clone()));
+    response_received_event.Wait();
+    return result;
+  }
+
+ private:
+  void SendMessageSyncOnWorkerThread(base::WaitableEvent* event,
+                                     base::Value* result,
+                                     bool internal,
+                                     const std::string& channel,
+                                     base::Value arguments) {
+    electron_browser_ptr_->get()->MessageSync(
+        internal, channel, std::move(arguments),
+        base::BindOnce(&IPCRenderer::ReturnSyncResponseToMainThread,
+                       base::Unretained(event), base::Unretained(result)));
+  }
+  static void ReturnSyncResponseToMainThread(base::WaitableEvent* event,
+                                             base::Value* result,
+                                             base::Value response) {
+    *result = std::move(response);
+    event->Signal();
+  }
+
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+  scoped_refptr<atom::mojom::ThreadSafeElectronBrowserPtr>
+      electron_browser_ptr_;
+};
+
+void Initialize(v8::Local<v8::Object> exports,
+                v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context,
+                void* priv) {
+  mate::Dictionary dict(context->GetIsolate(), exports);
+  dict.Set("ipc", IPCRenderer::Create(context->GetIsolate()));
+}
+
+}  // namespace
+
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_renderer_ipc, Initialize)

shell/renderer/api/atom_api_spell_check_client.cc

@@ -0,0 +1,275 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/renderer/api/atom_api_spell_check_client.h"
+
+#include <map>
+#include <set>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "base/logging.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "components/spellcheck/renderer/spellcheck_worditerator.h"
+#include "native_mate/converter.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/function_template.h"
+#include "third_party/blink/public/web/web_text_checking_completion.h"
+#include "third_party/blink/public/web/web_text_checking_result.h"
+#include "third_party/icu/source/common/unicode/uscript.h"
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+bool HasWordCharacters(const base::string16& text, int index) {
+  const base::char16* data = text.data();
+  int length = text.length();
+  while (index < length) {
+    uint32_t code = 0;
+    U16_NEXT(data, index, length, code);
+    UErrorCode error = U_ZERO_ERROR;
+    if (uscript_getScript(code, &error) != USCRIPT_COMMON)
+      return true;
+  }
+  return false;
+}
+
+struct Word {
+  blink::WebTextCheckingResult result;
+  base::string16 text;
+  std::vector<base::string16> contraction_words;
+};
+
+}  // namespace
+
+class SpellCheckClient::SpellcheckRequest {
+ public:
+  SpellcheckRequest(
+      const base::string16& text,
+      std::unique_ptr<blink::WebTextCheckingCompletion> completion)
+      : text_(text), completion_(std::move(completion)) {}
+  ~SpellcheckRequest() {}
+
+  const base::string16& text() const { return text_; }
+  blink::WebTextCheckingCompletion* completion() { return completion_.get(); }
+  std::vector<Word>& wordlist() { return word_list_; }
+
+ private:
+  base::string16 text_;          // Text to be checked in this task.
+  std::vector<Word> word_list_;  // List of Words found in text
+  // The interface to send the misspelled ranges to WebKit.
+  std::unique_ptr<blink::WebTextCheckingCompletion> completion_;
+
+  DISALLOW_COPY_AND_ASSIGN(SpellcheckRequest);
+};
+
+SpellCheckClient::SpellCheckClient(const std::string& language,
+                                   v8::Isolate* isolate,
+                                   v8::Local<v8::Object> provider)
+    : pending_request_param_(nullptr),
+      isolate_(isolate),
+      context_(isolate, isolate->GetCurrentContext()),
+      provider_(isolate, provider) {
+  DCHECK(!context_.IsEmpty());
+
+  character_attributes_.SetDefaultLanguage(language);
+
+  // Persistent the method.
+  mate::Dictionary dict(isolate, provider);
+  dict.Get("spellCheck", &spell_check_);
+}
+
+SpellCheckClient::~SpellCheckClient() {
+  context_.Reset();
+}
+
+void SpellCheckClient::RequestCheckingOfText(
+    const blink::WebString& textToCheck,
+    std::unique_ptr<blink::WebTextCheckingCompletion> completionCallback) {
+  base::string16 text(textToCheck.Utf16());
+  // Ignore invalid requests.
+  if (text.empty() || !HasWordCharacters(text, 0)) {
+    completionCallback->DidCancelCheckingText();
+    return;
+  }
+
+  // Clean up the previous request before starting a new request.
+  if (pending_request_param_) {
+    pending_request_param_->completion()->DidCancelCheckingText();
+  }
+
+  pending_request_param_.reset(
+      new SpellcheckRequest(text, std::move(completionCallback)));
+
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&SpellCheckClient::SpellCheckText, AsWeakPtr()));
+}
+
+bool SpellCheckClient::IsSpellCheckingEnabled() const {
+  return true;
+}
+
+void SpellCheckClient::ShowSpellingUI(bool show) {}
+
+bool SpellCheckClient::IsShowingSpellingUI() {
+  return false;
+}
+
+void SpellCheckClient::UpdateSpellingUIWithMisspelledWord(
+    const blink::WebString& word) {}
+
+void SpellCheckClient::SpellCheckText() {
+  const auto& text = pending_request_param_->text();
+  if (text.empty() || spell_check_.IsEmpty()) {
+    pending_request_param_->completion()->DidCancelCheckingText();
+    pending_request_param_ = nullptr;
+    return;
+  }
+
+  if (!text_iterator_.IsInitialized() &&
+      !text_iterator_.Initialize(&character_attributes_, true)) {
+    // We failed to initialize text_iterator_, return as spelled correctly.
+    VLOG(1) << "Failed to initialize SpellcheckWordIterator";
+    return;
+  }
+
+  if (!contraction_iterator_.IsInitialized() &&
+      !contraction_iterator_.Initialize(&character_attributes_, false)) {
+    // We failed to initialize the word iterator, return as spelled correctly.
+    VLOG(1) << "Failed to initialize contraction_iterator_";
+    return;
+  }
+
+  text_iterator_.SetText(text.c_str(), text.size());
+
+  SpellCheckScope scope(*this);
+  base::string16 word;
+  size_t word_start;
+  size_t word_length;
+  std::set<base::string16> words;
+  auto& word_list = pending_request_param_->wordlist();
+  Word word_entry;
+  for (;;) {  // Run until end of text
+    const auto status =
+        text_iterator_.GetNextWord(&word, &word_start, &word_length);
+    if (status == SpellcheckWordIterator::IS_END_OF_TEXT)
+      break;
+    if (status == SpellcheckWordIterator::IS_SKIPPABLE)
+      continue;
+
+    word_entry.result.location = base::checked_cast<int>(word_start);
+    word_entry.result.length = base::checked_cast<int>(word_length);
+    word_entry.text = word;
+    word_entry.contraction_words.clear();
+
+    word_list.push_back(word_entry);
+    words.insert(word);
+    // If the given word is a concatenated word of two or more valid words
+    // (e.g. "hello:hello"), we should treat it as a valid word.
+    if (IsContraction(scope, word, &word_entry.contraction_words)) {
+      for (const auto& w : word_entry.contraction_words) {
+        words.insert(w);
+      }
+    }
+  }
+
+  // Send out all the words data to the spellchecker to check
+  SpellCheckWords(scope, words);
+}
+
+void SpellCheckClient::OnSpellCheckDone(
+    const std::vector<base::string16>& misspelled_words) {
+  std::vector<blink::WebTextCheckingResult> results;
+  std::unordered_set<base::string16> misspelled(misspelled_words.begin(),
+                                                misspelled_words.end());
+
+  auto& word_list = pending_request_param_->wordlist();
+
+  for (const auto& word : word_list) {
+    if (misspelled.find(word.text) != misspelled.end()) {
+      // If this is a contraction, iterate through parts and accept the word
+      // if none of them are misspelled
+      if (!word.contraction_words.empty()) {
+        auto all_correct = true;
+        for (const auto& contraction_word : word.contraction_words) {
+          if (misspelled.find(contraction_word) != misspelled.end()) {
+            all_correct = false;
+            break;
+          }
+        }
+        if (all_correct)
+          continue;
+      }
+      results.push_back(word.result);
+    }
+  }
+  pending_request_param_->completion()->DidFinishCheckingText(results);
+  pending_request_param_ = nullptr;
+}
+
+void SpellCheckClient::SpellCheckWords(const SpellCheckScope& scope,
+                                       const std::set<base::string16>& words) {
+  DCHECK(!scope.spell_check_.IsEmpty());
+
+  v8::Local<v8::FunctionTemplate> templ = mate::CreateFunctionTemplate(
+      isolate_,
+      base::BindRepeating(&SpellCheckClient::OnSpellCheckDone, AsWeakPtr()));
+
+  auto context = isolate_->GetCurrentContext();
+  v8::Local<v8::Value> args[] = {mate::ConvertToV8(isolate_, words),
+                                 templ->GetFunction(context).ToLocalChecked()};
+  // Call javascript with the words and the callback function
+  scope.spell_check_->Call(context, scope.provider_, 2, args).IsEmpty();
+}
+
+// Returns whether or not the given string is a contraction.
+// This function is a fall-back when the SpellcheckWordIterator class
+// returns a concatenated word which is not in the selected dictionary
+// (e.g. "in'n'out") but each word is valid.
+// Output variable contraction_words will contain individual
+// words in the contraction.
+bool SpellCheckClient::IsContraction(
+    const SpellCheckScope& scope,
+    const base::string16& contraction,
+    std::vector<base::string16>* contraction_words) {
+  DCHECK(contraction_iterator_.IsInitialized());
+
+  contraction_iterator_.SetText(contraction.c_str(), contraction.length());
+
+  base::string16 word;
+  size_t word_start;
+  size_t word_length;
+  for (auto status =
+           contraction_iterator_.GetNextWord(&word, &word_start, &word_length);
+       status != SpellcheckWordIterator::IS_END_OF_TEXT;
+       status = contraction_iterator_.GetNextWord(&word, &word_start,
+                                                  &word_length)) {
+    if (status == SpellcheckWordIterator::IS_SKIPPABLE)
+      continue;
+
+    contraction_words->push_back(word);
+  }
+  return contraction_words->size() > 1;
+}
+
+SpellCheckClient::SpellCheckScope::SpellCheckScope(
+    const SpellCheckClient& client)
+    : handle_scope_(client.isolate_),
+      context_scope_(
+          v8::Local<v8::Context>::New(client.isolate_, client.context_)),
+      provider_(client.provider_.NewHandle()),
+      spell_check_(client.spell_check_.NewHandle()) {}
+
+SpellCheckClient::SpellCheckScope::~SpellCheckScope() = default;
+
+}  // namespace api
+
+}  // namespace atom

shell/renderer/api/atom_api_spell_check_client.h

@@ -0,0 +1,114 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_
+#define ATOM_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_
+
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/memory/weak_ptr.h"
+#include "components/spellcheck/renderer/spellcheck_worditerator.h"
+#include "native_mate/scoped_persistent.h"
+#include "third_party/blink/public/platform/web_spell_check_panel_host_client.h"
+#include "third_party/blink/public/platform/web_vector.h"
+#include "third_party/blink/public/web/web_text_check_client.h"
+
+namespace blink {
+struct WebTextCheckingResult;
+class WebTextCheckingCompletion;
+}  // namespace blink
+
+namespace atom {
+
+namespace api {
+
+class SpellCheckClient : public blink::WebSpellCheckPanelHostClient,
+                         public blink::WebTextCheckClient,
+                         public base::SupportsWeakPtr<SpellCheckClient> {
+ public:
+  SpellCheckClient(const std::string& language,
+                   v8::Isolate* isolate,
+                   v8::Local<v8::Object> provider);
+  ~SpellCheckClient() override;
+
+ private:
+  class SpellcheckRequest;
+  // blink::WebTextCheckClient:
+  void RequestCheckingOfText(const blink::WebString& textToCheck,
+                             std::unique_ptr<blink::WebTextCheckingCompletion>
+                                 completionCallback) override;
+  bool IsSpellCheckingEnabled() const override;
+
+  // blink::WebSpellCheckPanelHostClient:
+  void ShowSpellingUI(bool show) override;
+  bool IsShowingSpellingUI() override;
+  void UpdateSpellingUIWithMisspelledWord(
+      const blink::WebString& word) override;
+
+  struct SpellCheckScope {
+    v8::HandleScope handle_scope_;
+    v8::Context::Scope context_scope_;
+    v8::Local<v8::Object> provider_;
+    v8::Local<v8::Function> spell_check_;
+
+    explicit SpellCheckScope(const SpellCheckClient& client);
+    ~SpellCheckScope();
+  };
+
+  // Run through the word iterator and send out requests
+  // to the JS API for checking spellings of words in the current
+  // request.
+  void SpellCheckText();
+
+  // Call JavaScript to check spelling a word.
+  // The javascript function will callback OnSpellCheckDone
+  // with the results of all the misspelled words.
+  void SpellCheckWords(const SpellCheckScope& scope,
+                       const std::set<base::string16>& words);
+
+  // Returns whether or not the given word is a contraction of valid words
+  // (e.g. "word:word").
+  // Output variable contraction_words will contain individual
+  // words in the contraction.
+  bool IsContraction(const SpellCheckScope& scope,
+                     const base::string16& word,
+                     std::vector<base::string16>* contraction_words);
+
+  // Callback for the JS API which returns the list of misspelled words.
+  void OnSpellCheckDone(const std::vector<base::string16>& misspelled_words);
+
+  // Represents character attributes used for filtering out characters which
+  // are not supported by this SpellCheck object.
+  SpellcheckCharAttribute character_attributes_;
+
+  // Represents word iterators used in this spellchecker. The |text_iterator_|
+  // splits text provided by WebKit into words, contractions, or concatenated
+  // words. The |contraction_iterator_| splits a concatenated word extracted by
+  // |text_iterator_| into word components so we can treat a concatenated word
+  // consisting only of correct words as a correct word.
+  SpellcheckWordIterator text_iterator_;
+  SpellcheckWordIterator contraction_iterator_;
+
+  // The parameters of a pending background-spellchecking request.
+  // (When WebKit sends two or more requests, we cancel the previous
+  // requests so we do not have to use vectors.)
+  std::unique_ptr<SpellcheckRequest> pending_request_param_;
+
+  v8::Isolate* isolate_;
+  v8::Persistent<v8::Context> context_;
+  mate::ScopedPersistent<v8::Object> provider_;
+  mate::ScopedPersistent<v8::Function> spell_check_;
+
+  DISALLOW_COPY_AND_ASSIGN(SpellCheckClient);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_

shell/renderer/api/atom_api_web_frame.cc

@@ -0,0 +1,580 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "atom/common/api/api.mojom.h"
+#include "atom/common/api/event_emitter_caller.h"
+#include "atom/common/native_mate_converters/blink_converter.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/node_includes.h"
+#include "atom/common/promise_util.h"
+#include "atom/renderer/api/atom_api_spell_check_client.h"
+#include "base/memory/memory_pressure_listener.h"
+#include "content/public/renderer/render_frame.h"
+#include "content/public/renderer/render_frame_observer.h"
+#include "content/public/renderer/render_frame_visitor.h"
+#include "content/public/renderer/render_view.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
+#include "third_party/blink/public/platform/web_cache.h"
+#include "third_party/blink/public/platform/web_isolated_world_info.h"
+#include "third_party/blink/public/web/web_custom_element.h"
+#include "third_party/blink/public/web/web_document.h"
+#include "third_party/blink/public/web/web_element.h"
+#include "third_party/blink/public/web/web_frame_widget.h"
+#include "third_party/blink/public/web/web_ime_text_span.h"
+#include "third_party/blink/public/web/web_input_method_controller.h"
+#include "third_party/blink/public/web/web_local_frame.h"
+#include "third_party/blink/public/web/web_script_execution_callback.h"
+#include "third_party/blink/public/web/web_script_source.h"
+#include "third_party/blink/public/web/web_view.h"
+#include "url/url_util.h"
+
+namespace mate {
+
+template <>
+struct Converter<blink::WebLocalFrame::ScriptExecutionType> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     blink::WebLocalFrame::ScriptExecutionType* out) {
+    std::string execution_type;
+    if (!ConvertFromV8(isolate, val, &execution_type))
+      return false;
+    if (execution_type == "asynchronous") {
+      *out = blink::WebLocalFrame::kAsynchronous;
+    } else if (execution_type == "asynchronousBlockingOnload") {
+      *out = blink::WebLocalFrame::kAsynchronousBlockingOnload;
+    } else if (execution_type == "synchronous") {
+      *out = blink::WebLocalFrame::kSynchronous;
+    } else {
+      return false;
+    }
+    return true;
+  }
+};
+
+}  // namespace mate
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+content::RenderFrame* GetRenderFrame(v8::Local<v8::Value> value) {
+  v8::Local<v8::Context> context =
+      v8::Local<v8::Object>::Cast(value)->CreationContext();
+  if (context.IsEmpty())
+    return nullptr;
+  blink::WebLocalFrame* frame = blink::WebLocalFrame::FrameForContext(context);
+  if (!frame)
+    return nullptr;
+  return content::RenderFrame::FromWebFrame(frame);
+}
+
+class RenderFrameStatus : public content::RenderFrameObserver {
+ public:
+  explicit RenderFrameStatus(content::RenderFrame* render_frame)
+      : content::RenderFrameObserver(render_frame) {}
+  ~RenderFrameStatus() final {}
+
+  bool is_ok() { return render_frame() != nullptr; }
+
+  // RenderFrameObserver implementation.
+  void OnDestruct() final {}
+};
+
+class ScriptExecutionCallback : public blink::WebScriptExecutionCallback {
+ public:
+  explicit ScriptExecutionCallback(atom::util::Promise promise)
+      : promise_(std::move(promise)) {}
+  ~ScriptExecutionCallback() override {}
+
+  void Completed(
+      const blink::WebVector<v8::Local<v8::Value>>& result) override {
+    if (!result.empty()) {
+      if (!result[0].IsEmpty()) {
+        // Right now only single results per frame is supported.
+        promise_.Resolve(result[0]);
+      } else {
+        promise_.RejectWithErrorMessage(
+            "Script failed to execute, this normally means an error "
+            "was thrown. Check the renderer console for the error.");
+      }
+    } else {
+      promise_.RejectWithErrorMessage(
+          "WebFrame was removed before script could run. This normally means "
+          "the underlying frame was destroyed");
+    }
+    delete this;
+  }
+
+ private:
+  atom::util::Promise promise_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScriptExecutionCallback);
+};
+
+class FrameSetSpellChecker : public content::RenderFrameVisitor {
+ public:
+  FrameSetSpellChecker(SpellCheckClient* spell_check_client,
+                       content::RenderFrame* main_frame)
+      : spell_check_client_(spell_check_client), main_frame_(main_frame) {
+    content::RenderFrame::ForEach(this);
+    main_frame->GetWebFrame()->SetSpellCheckPanelHostClient(spell_check_client);
+  }
+
+  bool Visit(content::RenderFrame* render_frame) override {
+    auto* view = render_frame->GetRenderView();
+    if (view->GetMainRenderFrame() == main_frame_ ||
+        (render_frame->IsMainFrame() && render_frame == main_frame_)) {
+      render_frame->GetWebFrame()->SetTextCheckClient(spell_check_client_);
+    }
+    return true;
+  }
+
+ private:
+  SpellCheckClient* spell_check_client_;
+  content::RenderFrame* main_frame_;
+
+  DISALLOW_COPY_AND_ASSIGN(FrameSetSpellChecker);
+};
+
+class SpellCheckerHolder : public content::RenderFrameObserver {
+ public:
+  // Find existing holder for the |render_frame|.
+  static SpellCheckerHolder* FromRenderFrame(
+      content::RenderFrame* render_frame) {
+    for (auto* holder : instances_) {
+      if (holder->render_frame() == render_frame)
+        return holder;
+    }
+    return nullptr;
+  }
+
+  SpellCheckerHolder(content::RenderFrame* render_frame,
+                     std::unique_ptr<SpellCheckClient> spell_check_client)
+      : content::RenderFrameObserver(render_frame),
+        spell_check_client_(std::move(spell_check_client)) {
+    DCHECK(!FromRenderFrame(render_frame));
+    instances_.insert(this);
+  }
+
+  ~SpellCheckerHolder() final { instances_.erase(this); }
+
+  void UnsetAndDestroy() {
+    FrameSetSpellChecker set_spell_checker(nullptr, render_frame());
+    delete this;
+  }
+
+  // RenderFrameObserver implementation.
+  void OnDestruct() final {
+    // Since we delete this in WillReleaseScriptContext, this method is unlikely
+    // to be called, but override anyway since I'm not sure if there are some
+    // corner cases.
+    //
+    // Note that while there are two "delete this", it is totally fine as the
+    // observer unsubscribes automatically in destructor and the other one won't
+    // be called.
+    //
+    // Also note that we should not call UnsetAndDestroy here, as the render
+    // frame is going to be destroyed.
+    delete this;
+  }
+
+  void WillReleaseScriptContext(v8::Local<v8::Context> context,
+                                int world_id) final {
+    // Unset spell checker when the script context is going to be released, as
+    // the spell check implementation lives there.
+    UnsetAndDestroy();
+  }
+
+ private:
+  static std::set<SpellCheckerHolder*> instances_;
+
+  std::unique_ptr<SpellCheckClient> spell_check_client_;
+};
+
+}  // namespace
+
+// static
+std::set<SpellCheckerHolder*> SpellCheckerHolder::instances_;
+
+void SetName(v8::Local<v8::Value> window, const std::string& name) {
+  GetRenderFrame(window)->GetWebFrame()->SetName(
+      blink::WebString::FromUTF8(name));
+}
+
+void SetZoomLevel(v8::Local<v8::Value> window, double level) {
+  content::RenderFrame* render_frame = GetRenderFrame(window);
+  mojom::ElectronBrowserPtr browser_ptr;
+  render_frame->GetRemoteInterfaces()->GetInterface(
+      mojo::MakeRequest(&browser_ptr));
+  browser_ptr->SetTemporaryZoomLevel(level);
+}
+
+double GetZoomLevel(v8::Local<v8::Value> window) {
+  double result = 0.0;
+  content::RenderFrame* render_frame = GetRenderFrame(window);
+  mojom::ElectronBrowserPtr browser_ptr;
+  render_frame->GetRemoteInterfaces()->GetInterface(
+      mojo::MakeRequest(&browser_ptr));
+  browser_ptr->DoGetZoomLevel(&result);
+  return result;
+}
+
+void SetZoomFactor(v8::Local<v8::Value> window, double factor) {
+  SetZoomLevel(window, blink::WebView::ZoomFactorToZoomLevel(factor));
+}
+
+double GetZoomFactor(v8::Local<v8::Value> window) {
+  return blink::WebView::ZoomLevelToZoomFactor(GetZoomLevel(window));
+}
+
+void SetVisualZoomLevelLimits(v8::Local<v8::Value> window,
+                              double min_level,
+                              double max_level) {
+  blink::WebFrame* web_frame = GetRenderFrame(window)->GetWebFrame();
+  web_frame->View()->SetDefaultPageScaleLimits(min_level, max_level);
+  web_frame->View()->SetIgnoreViewportTagScaleLimits(true);
+}
+
+void SetLayoutZoomLevelLimits(v8::Local<v8::Value> window,
+                              double min_level,
+                              double max_level) {
+  blink::WebFrame* web_frame = GetRenderFrame(window)->GetWebFrame();
+  web_frame->View()->ZoomLimitsChanged(min_level, max_level);
+}
+
+void AllowGuestViewElementDefinition(v8::Isolate* isolate,
+                                     v8::Local<v8::Value> window,
+                                     v8::Local<v8::Object> context,
+                                     v8::Local<v8::Function> register_cb) {
+  v8::HandleScope handle_scope(isolate);
+  v8::Context::Scope context_scope(context->CreationContext());
+  blink::WebCustomElement::EmbedderNamesAllowedScope embedder_names_scope;
+  GetRenderFrame(context)->GetWebFrame()->RequestExecuteV8Function(
+      context->CreationContext(), register_cb, v8::Null(isolate), 0, nullptr,
+      nullptr);
+}
+
+int GetWebFrameId(v8::Local<v8::Value> window,
+                  v8::Local<v8::Value> content_window) {
+  // Get the WebLocalFrame before (possibly) executing any user-space JS while
+  // getting the |params|. We track the status of the RenderFrame via an
+  // observer in case it is deleted during user code execution.
+  content::RenderFrame* render_frame = GetRenderFrame(content_window);
+  RenderFrameStatus render_frame_status(render_frame);
+
+  if (!render_frame_status.is_ok())
+    return -1;
+
+  blink::WebLocalFrame* frame = render_frame->GetWebFrame();
+  // Parent must exist.
+  blink::WebFrame* parent_frame = frame->Parent();
+  DCHECK(parent_frame);
+  DCHECK(parent_frame->IsWebLocalFrame());
+
+  return render_frame->GetRoutingID();
+}
+
+void SetSpellCheckProvider(mate::Arguments* args,
+                           v8::Local<v8::Value> window,
+                           const std::string& language,
+                           v8::Local<v8::Object> provider) {
+  auto context = args->isolate()->GetCurrentContext();
+  if (!provider->Has(context, mate::StringToV8(args->isolate(), "spellCheck"))
+           .ToChecked()) {
+    args->ThrowError("\"spellCheck\" has to be defined");
+    return;
+  }
+
+  // Remove the old client.
+  content::RenderFrame* render_frame = GetRenderFrame(window);
+  auto* existing = SpellCheckerHolder::FromRenderFrame(render_frame);
+  if (existing)
+    existing->UnsetAndDestroy();
+
+  // Set spellchecker for all live frames in the same process or
+  // in the sandbox mode for all live sub frames to this WebFrame.
+  auto spell_check_client =
+      std::make_unique<SpellCheckClient>(language, args->isolate(), provider);
+  FrameSetSpellChecker spell_checker(spell_check_client.get(), render_frame);
+
+  // Attach the spell checker to RenderFrame.
+  new SpellCheckerHolder(render_frame, std::move(spell_check_client));
+}
+
+void InsertText(v8::Local<v8::Value> window, const std::string& text) {
+  blink::WebFrame* web_frame = GetRenderFrame(window)->GetWebFrame();
+  if (web_frame->IsWebLocalFrame()) {
+    web_frame->ToWebLocalFrame()
+        ->FrameWidget()
+        ->GetActiveWebInputMethodController()
+        ->CommitText(blink::WebString::FromUTF8(text),
+                     blink::WebVector<blink::WebImeTextSpan>(),
+                     blink::WebRange(), 0);
+  }
+}
+
+base::string16 InsertCSS(v8::Local<v8::Value> window, const std::string& css) {
+  blink::WebFrame* web_frame = GetRenderFrame(window)->GetWebFrame();
+  if (web_frame->IsWebLocalFrame()) {
+    return web_frame->ToWebLocalFrame()
+        ->GetDocument()
+        .InsertStyleSheet(blink::WebString::FromUTF8(css))
+        .Utf16();
+  }
+  return base::string16();
+}
+
+void RemoveInsertedCSS(v8::Local<v8::Value> window, const base::string16& key) {
+  blink::WebFrame* web_frame = GetRenderFrame(window)->GetWebFrame();
+  if (web_frame->IsWebLocalFrame()) {
+    web_frame->ToWebLocalFrame()->GetDocument().RemoveInsertedStyleSheet(
+        blink::WebString::FromUTF16(key));
+  }
+}
+
+v8::Local<v8::Promise> ExecuteJavaScript(mate::Arguments* args,
+                                         v8::Local<v8::Value> window,
+                                         const base::string16& code) {
+  v8::Isolate* isolate = args->isolate();
+  util::Promise promise(isolate);
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+
+  bool has_user_gesture = false;
+  args->GetNext(&has_user_gesture);
+
+  GetRenderFrame(window)->GetWebFrame()->RequestExecuteScriptAndReturnValue(
+      blink::WebScriptSource(blink::WebString::FromUTF16(code)),
+      has_user_gesture, new ScriptExecutionCallback(std::move(promise)));
+
+  return handle;
+}
+
+v8::Local<v8::Promise> ExecuteJavaScriptInIsolatedWorld(
+    mate::Arguments* args,
+    v8::Local<v8::Value> window,
+    int world_id,
+    const std::vector<mate::Dictionary>& scripts) {
+  v8::Isolate* isolate = args->isolate();
+  util::Promise promise(isolate);
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+
+  std::vector<blink::WebScriptSource> sources;
+
+  for (const auto& script : scripts) {
+    base::string16 code;
+    base::string16 url;
+    int start_line = 1;
+    script.Get("url", &url);
+    script.Get("startLine", &start_line);
+
+    if (!script.Get("code", &code)) {
+      promise.RejectWithErrorMessage("Invalid 'code'");
+      return handle;
+    }
+
+    sources.emplace_back(
+        blink::WebScriptSource(blink::WebString::FromUTF16(code),
+                               blink::WebURL(GURL(url)), start_line));
+  }
+
+  bool has_user_gesture = false;
+  args->GetNext(&has_user_gesture);
+
+  blink::WebLocalFrame::ScriptExecutionType scriptExecutionType =
+      blink::WebLocalFrame::kSynchronous;
+  args->GetNext(&scriptExecutionType);
+
+  // Debugging tip: if you see a crash stack trace beginning from this call,
+  // then it is very likely that some exception happened when executing the
+  // "content_script/init.js" script.
+  GetRenderFrame(window)->GetWebFrame()->RequestExecuteScriptInIsolatedWorld(
+      world_id, &sources.front(), sources.size(), has_user_gesture,
+      scriptExecutionType, new ScriptExecutionCallback(std::move(promise)));
+
+  return handle;
+}
+
+void SetIsolatedWorldInfo(v8::Local<v8::Value> window,
+                          int world_id,
+                          const mate::Dictionary& options,
+                          mate::Arguments* args) {
+  std::string origin_url, security_policy, name;
+  options.Get("securityOrigin", &origin_url);
+  options.Get("csp", &security_policy);
+  options.Get("name", &name);
+
+  if (!security_policy.empty() && origin_url.empty()) {
+    args->ThrowError(
+        "If csp is specified, securityOrigin should also be specified");
+    return;
+  }
+
+  blink::WebIsolatedWorldInfo info;
+  info.security_origin = blink::WebSecurityOrigin::CreateFromString(
+      blink::WebString::FromUTF8(origin_url));
+  info.content_security_policy = blink::WebString::FromUTF8(security_policy);
+  info.human_readable_name = blink::WebString::FromUTF8(name);
+  GetRenderFrame(window)->GetWebFrame()->SetIsolatedWorldInfo(world_id, info);
+}
+
+blink::WebCache::ResourceTypeStats GetResourceUsage(v8::Isolate* isolate) {
+  blink::WebCache::ResourceTypeStats stats;
+  blink::WebCache::GetResourceTypeStats(&stats);
+  return stats;
+}
+
+void ClearCache(v8::Isolate* isolate) {
+  isolate->IdleNotificationDeadline(0.5);
+  blink::WebCache::Clear();
+  base::MemoryPressureListener::NotifyMemoryPressure(
+      base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
+}
+
+v8::Local<v8::Value> FindFrameByRoutingId(v8::Isolate* isolate,
+                                          v8::Local<v8::Value> window,
+                                          int routing_id) {
+  content::RenderFrame* render_frame =
+      content::RenderFrame::FromRoutingID(routing_id);
+  if (render_frame)
+    return render_frame->GetWebFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> GetOpener(v8::Isolate* isolate,
+                               v8::Local<v8::Value> window) {
+  blink::WebFrame* frame = GetRenderFrame(window)->GetWebFrame()->Opener();
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+// Don't name it as GetParent, Windows has API with same name.
+v8::Local<v8::Value> GetFrameParent(v8::Isolate* isolate,
+                                    v8::Local<v8::Value> window) {
+  blink::WebFrame* frame = GetRenderFrame(window)->GetWebFrame()->Parent();
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> GetTop(v8::Isolate* isolate, v8::Local<v8::Value> window) {
+  blink::WebFrame* frame = GetRenderFrame(window)->GetWebFrame()->Top();
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> GetFirstChild(v8::Isolate* isolate,
+                                   v8::Local<v8::Value> window) {
+  blink::WebFrame* frame = GetRenderFrame(window)->GetWebFrame()->FirstChild();
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> GetNextSibling(v8::Isolate* isolate,
+                                    v8::Local<v8::Value> window) {
+  blink::WebFrame* frame = GetRenderFrame(window)->GetWebFrame()->NextSibling();
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> GetFrameForSelector(v8::Isolate* isolate,
+                                         v8::Local<v8::Value> window,
+                                         const std::string& selector) {
+  blink::WebElement element =
+      GetRenderFrame(window)->GetWebFrame()->GetDocument().QuerySelector(
+          blink::WebString::FromUTF8(selector));
+  if (element.IsNull())  // not found
+    return v8::Null(isolate);
+
+  blink::WebFrame* frame = blink::WebFrame::FromFrameOwnerElement(element);
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> FindFrameByName(v8::Isolate* isolate,
+                                     v8::Local<v8::Value> window,
+                                     const std::string& name) {
+  blink::WebFrame* frame =
+      GetRenderFrame(window)->GetWebFrame()->FindFrameByName(
+          blink::WebString::FromUTF8(name));
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+int GetRoutingId(v8::Local<v8::Value> window) {
+  return GetRenderFrame(window)->GetRoutingID();
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+void Initialize(v8::Local<v8::Object> exports,
+                v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context,
+                void* priv) {
+  using namespace atom::api;  // NOLINT(build/namespaces)
+
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.SetMethod("setName", &SetName);
+  dict.SetMethod("setZoomLevel", &SetZoomLevel);
+  dict.SetMethod("getZoomLevel", &GetZoomLevel);
+  dict.SetMethod("setZoomFactor", &SetZoomFactor);
+  dict.SetMethod("getZoomFactor", &GetZoomFactor);
+  dict.SetMethod("setVisualZoomLevelLimits", &SetVisualZoomLevelLimits);
+  dict.SetMethod("setLayoutZoomLevelLimits", &SetLayoutZoomLevelLimits);
+  dict.SetMethod("allowGuestViewElementDefinition",
+                 &AllowGuestViewElementDefinition);
+  dict.SetMethod("getWebFrameId", &GetWebFrameId);
+  dict.SetMethod("setSpellCheckProvider", &SetSpellCheckProvider);
+  dict.SetMethod("insertText", &InsertText);
+  dict.SetMethod("insertCSS", &InsertCSS);
+  dict.SetMethod("removeInsertedCSS", &RemoveInsertedCSS);
+  dict.SetMethod("executeJavaScript", &ExecuteJavaScript);
+  dict.SetMethod("executeJavaScriptInIsolatedWorld",
+                 &ExecuteJavaScriptInIsolatedWorld);
+  dict.SetMethod("setIsolatedWorldInfo", &SetIsolatedWorldInfo);
+  dict.SetMethod("getResourceUsage", &GetResourceUsage);
+  dict.SetMethod("clearCache", &ClearCache);
+  dict.SetMethod("_findFrameByRoutingId", &FindFrameByRoutingId);
+  dict.SetMethod("_getFrameForSelector", &GetFrameForSelector);
+  dict.SetMethod("_findFrameByName", &FindFrameByName);
+  dict.SetMethod("_getOpener", &GetOpener);
+  dict.SetMethod("_getParent", &GetFrameParent);
+  dict.SetMethod("_getTop", &GetTop);
+  dict.SetMethod("_getFirstChild", &GetFirstChild);
+  dict.SetMethod("_getNextSibling", &GetNextSibling);
+  dict.SetMethod("_getRoutingId", &GetRoutingId);
+}
+
+}  // namespace
+
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_renderer_web_frame, Initialize)