feat: add webFrameMain API to the main process (#25464)

shell/browser/api/electron_api_web_contents.cc

@@ -62,6 +62,7 @@
 #include "shell/browser/api/electron_api_browser_window.h"
 #include "shell/browser/api/electron_api_debugger.h"
 #include "shell/browser/api/electron_api_session.h"
+#include "shell/browser/api/electron_api_web_frame_main.h"
 #include "shell/browser/api/message_port.h"
 #include "shell/browser/browser.h"
 #include "shell/browser/child_web_contents_tracker.h"
@@ -87,6 +88,7 @@
 #include "shell/common/gin_converters/callback_converter.h"
 #include "shell/common/gin_converters/content_converter.h"
 #include "shell/common/gin_converters/file_path_converter.h"
+#include "shell/common/gin_converters/frame_converter.h"
 #include "shell/common/gin_converters/gfx_converter.h"
 #include "shell/common/gin_converters/gurl_converter.h"
 #include "shell/common/gin_converters/image_converter.h"
@@ -1324,6 +1326,10 @@ void WebContents::UpdateDraggableRegions(
 
 void WebContents::RenderFrameDeleted(
     content::RenderFrameHost* render_frame_host) {
+  // A WebFrameMain can outlive its RenderFrameHost so we need to mark it as
+  // disposed to prevent access to it.
+  WebFrameMain::RenderFrameDeleted(render_frame_host);
+
   // A RenderFrameHost can be destroyed before the related Mojo binding is
   // closed, which can result in Mojo calls being sent for RenderFrameHosts
   // that no longer exist. To prevent this from happening, when a
@@ -2835,6 +2841,10 @@ bool WebContents::WasInitiallyShown() {
   return initially_shown_;
 }
 
+content::RenderFrameHost* WebContents::MainFrame() {
+  return web_contents()->GetMainFrame();
+}
+
 void WebContents::GrantOriginAccess(const GURL& url) {
   content::ChildProcessSecurityPolicy::GetInstance()->GrantCommitOrigin(
       web_contents()->GetMainFrame()->GetProcess()->GetID(),
@@ -3031,6 +3041,7 @@ v8::Local<v8::ObjectTemplate> WebContents::FillObjectTemplate(
       .SetProperty("devToolsWebContents", &WebContents::DevToolsWebContents)
       .SetProperty("debugger", &WebContents::Debugger)
       .SetProperty("_initiallyShown", &WebContents::WasInitiallyShown)
+      .SetProperty("mainFrame", &WebContents::MainFrame)
       .Build();
 }
 

shell/browser/api/electron_api_web_contents.h

@@ -397,6 +397,7 @@ class WebContents : public gin::Wrappable<WebContents>,
   v8::Local<v8::Value> DevToolsWebContents(v8::Isolate* isolate);
   v8::Local<v8::Value> Debugger(v8::Isolate* isolate);
   bool WasInitiallyShown();
+  content::RenderFrameHost* MainFrame();
 
   WebContentsZoomController* GetZoomController() { return zoom_controller_; }
 

shell/browser/api/electron_api_web_frame_main.cc

@@ -0,0 +1,258 @@
+// Copyright (c) 2020 Samuel Maddock <sam@samuelmaddock.com>.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "shell/browser/api/electron_api_web_frame_main.h"
+
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "content/browser/renderer_host/frame_tree_node.h"  // nogncheck
+#include "content/public/browser/render_frame_host.h"
+#include "gin/object_template_builder.h"
+#include "shell/browser/browser.h"
+#include "shell/browser/javascript_environment.h"
+#include "shell/common/gin_converters/frame_converter.h"
+#include "shell/common/gin_converters/gurl_converter.h"
+#include "shell/common/gin_converters/value_converter.h"
+#include "shell/common/gin_helper/dictionary.h"
+#include "shell/common/gin_helper/error_thrower.h"
+#include "shell/common/gin_helper/object_template_builder.h"
+#include "shell/common/gin_helper/promise.h"
+#include "shell/common/node_includes.h"
+
+namespace electron {
+
+namespace api {
+
+typedef std::unordered_map<content::RenderFrameHost*, WebFrameMain*>
+    RenderFrameMap;
+base::LazyInstance<RenderFrameMap>::DestructorAtExit g_render_frame_map =
+    LAZY_INSTANCE_INITIALIZER;
+
+WebFrameMain* FromRenderFrameHost(content::RenderFrameHost* rfh) {
+  auto frame_map = g_render_frame_map.Get();
+  auto iter = frame_map.find(rfh);
+  auto* web_frame = iter == frame_map.end() ? nullptr : iter->second;
+  return web_frame;
+}
+
+gin::WrapperInfo WebFrameMain::kWrapperInfo = {gin::kEmbedderNativeGin};
+
+WebFrameMain::WebFrameMain(content::RenderFrameHost* rfh) : render_frame_(rfh) {
+  g_render_frame_map.Get().emplace(rfh, this);
+}
+
+WebFrameMain::~WebFrameMain() {
+  MarkRenderFrameDisposed();
+}
+
+void WebFrameMain::MarkRenderFrameDisposed() {
+  g_render_frame_map.Get().erase(render_frame_);
+  render_frame_disposed_ = true;
+}
+
+bool WebFrameMain::CheckRenderFrame() const {
+  if (render_frame_disposed_) {
+    v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
+    v8::Locker locker(isolate);
+    v8::HandleScope scope(isolate);
+    gin_helper::ErrorThrower(isolate).ThrowError(
+        "Render frame was disposed before WebFrameMain could be accessed");
+    return false;
+  }
+  return true;
+}
+
+v8::Local<v8::Promise> WebFrameMain::ExecuteJavaScript(
+    gin::Arguments* args,
+    const base::string16& code) {
+  gin_helper::Promise<base::Value> promise(args->isolate());
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+
+  // Optional userGesture parameter
+  bool user_gesture;
+  if (!args->PeekNext().IsEmpty()) {
+    if (args->PeekNext()->IsBoolean()) {
+      args->GetNext(&user_gesture);
+    } else {
+      args->ThrowTypeError("userGesture must be a boolean");
+      return handle;
+    }
+  } else {
+    user_gesture = false;
+  }
+
+  if (render_frame_disposed_) {
+    promise.RejectWithErrorMessage(
+        "Render frame was disposed before WebFrameMain could be accessed");
+    return handle;
+  }
+
+  if (user_gesture) {
+    auto* ftn = content::FrameTreeNode::From(render_frame_);
+    ftn->UpdateUserActivationState(
+        blink::mojom::UserActivationUpdateType::kNotifyActivation,
+        blink::mojom::UserActivationNotificationType::kTest);
+  }
+
+  render_frame_->ExecuteJavaScriptForTests(
+      code, base::BindOnce([](gin_helper::Promise<base::Value> promise,
+                              base::Value value) { promise.Resolve(value); },
+                           std::move(promise)));
+
+  return handle;
+}
+
+bool WebFrameMain::Reload(v8::Isolate* isolate) {
+  if (!CheckRenderFrame())
+    return false;
+  return render_frame_->Reload();
+}
+
+int WebFrameMain::FrameTreeNodeID(v8::Isolate* isolate) const {
+  if (!CheckRenderFrame())
+    return -1;
+  return render_frame_->GetFrameTreeNodeId();
+}
+
+int WebFrameMain::ProcessID(v8::Isolate* isolate) const {
+  if (!CheckRenderFrame())
+    return -1;
+  return render_frame_->GetProcess()->GetID();
+}
+
+int WebFrameMain::RoutingID(v8::Isolate* isolate) const {
+  if (!CheckRenderFrame())
+    return -1;
+  return render_frame_->GetRoutingID();
+}
+
+GURL WebFrameMain::URL(v8::Isolate* isolate) const {
+  if (!CheckRenderFrame())
+    return GURL::EmptyGURL();
+  return render_frame_->GetLastCommittedURL();
+}
+
+content::RenderFrameHost* WebFrameMain::Top(v8::Isolate* isolate) const {
+  if (!CheckRenderFrame())
+    return nullptr;
+  return render_frame_->GetMainFrame();
+}
+
+content::RenderFrameHost* WebFrameMain::Parent(v8::Isolate* isolate) const {
+  if (!CheckRenderFrame())
+    return nullptr;
+  return render_frame_->GetParent();
+}
+
+std::vector<content::RenderFrameHost*> WebFrameMain::Frames(
+    v8::Isolate* isolate) const {
+  std::vector<content::RenderFrameHost*> frame_hosts;
+  if (!CheckRenderFrame())
+    return frame_hosts;
+
+  for (auto* rfh : render_frame_->GetFramesInSubtree()) {
+    if (rfh->GetParent() == render_frame_)
+      frame_hosts.push_back(rfh);
+  }
+
+  return frame_hosts;
+}
+
+std::vector<content::RenderFrameHost*> WebFrameMain::FramesInSubtree(
+    v8::Isolate* isolate) const {
+  std::vector<content::RenderFrameHost*> frame_hosts;
+  if (!CheckRenderFrame())
+    return frame_hosts;
+
+  for (auto* rfh : render_frame_->GetFramesInSubtree()) {
+    frame_hosts.push_back(rfh);
+  }
+
+  return frame_hosts;
+}
+
+// static
+gin::Handle<WebFrameMain> WebFrameMain::From(v8::Isolate* isolate,
+                                             content::RenderFrameHost* rfh) {
+  if (rfh == nullptr)
+    return gin::Handle<WebFrameMain>();
+  auto* web_frame = FromRenderFrameHost(rfh);
+  auto handle = gin::CreateHandle(
+      isolate, web_frame == nullptr ? new WebFrameMain(rfh) : web_frame);
+  return handle;
+}
+
+// static
+gin::Handle<WebFrameMain> WebFrameMain::FromID(v8::Isolate* isolate,
+                                               int render_process_id,
+                                               int render_frame_id) {
+  auto* rfh =
+      content::RenderFrameHost::FromID(render_process_id, render_frame_id);
+  return From(isolate, rfh);
+}
+
+// static
+void WebFrameMain::RenderFrameDeleted(content::RenderFrameHost* rfh) {
+  auto* web_frame = FromRenderFrameHost(rfh);
+  if (web_frame)
+    web_frame->MarkRenderFrameDisposed();
+}
+
+gin::ObjectTemplateBuilder WebFrameMain::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return gin::Wrappable<WebFrameMain>::GetObjectTemplateBuilder(isolate)
+      .SetMethod("executeJavaScript", &WebFrameMain::ExecuteJavaScript)
+      .SetMethod("reload", &WebFrameMain::Reload)
+      .SetProperty("frameTreeNodeId", &WebFrameMain::FrameTreeNodeID)
+      .SetProperty("processId", &WebFrameMain::ProcessID)
+      .SetProperty("routingId", &WebFrameMain::RoutingID)
+      .SetProperty("url", &WebFrameMain::URL)
+      .SetProperty("top", &WebFrameMain::Top)
+      .SetProperty("parent", &WebFrameMain::Parent)
+      .SetProperty("frames", &WebFrameMain::Frames)
+      .SetProperty("framesInSubtree", &WebFrameMain::FramesInSubtree);
+}
+
+const char* WebFrameMain::GetTypeName() {
+  return "WebFrameMain";
+}
+
+}  // namespace api
+
+}  // namespace electron
+
+namespace {
+
+using electron::api::WebFrameMain;
+
+v8::Local<v8::Value> FromID(gin_helper::ErrorThrower thrower,
+                            int render_process_id,
+                            int render_frame_id) {
+  if (!electron::Browser::Get()->is_ready()) {
+    thrower.ThrowError("WebFrameMain is available only after app ready");
+    return v8::Null(thrower.isolate());
+  }
+
+  return WebFrameMain::FromID(thrower.isolate(), render_process_id,
+                              render_frame_id)
+      .ToV8();
+}
+
+void Initialize(v8::Local<v8::Object> exports,
+                v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context,
+                void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  gin_helper::Dictionary dict(isolate, exports);
+  dict.SetMethod("fromId", &FromID);
+}
+
+}  // namespace
+
+NODE_LINKED_MODULE_CONTEXT_AWARE(electron_browser_web_frame_main, Initialize)

shell/browser/api/electron_api_web_frame_main.h

@@ -0,0 +1,94 @@
+// Copyright (c) 2020 Samuel Maddock <sam@samuelmaddock.com>.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef SHELL_BROWSER_API_ELECTRON_API_WEB_FRAME_MAIN_H_
+#define SHELL_BROWSER_API_ELECTRON_API_WEB_FRAME_MAIN_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "gin/handle.h"
+#include "gin/wrappable.h"
+
+class GURL;
+
+namespace content {
+class RenderFrameHost;
+}
+
+namespace gin {
+class Arguments;
+}
+
+namespace gin_helper {
+class Dictionary;
+}
+
+namespace electron {
+
+namespace api {
+
+// Bindings for accessing frames from the main process.
+class WebFrameMain : public gin::Wrappable<WebFrameMain> {
+ public:
+  static gin::Handle<WebFrameMain> FromID(v8::Isolate* isolate,
+                                          int render_process_id,
+                                          int render_frame_id);
+  static gin::Handle<WebFrameMain> From(
+      v8::Isolate* isolate,
+      content::RenderFrameHost* render_frame_host);
+
+  // Called to mark any RenderFrameHost as disposed by any WebFrameMain that
+  // may be holding a weak reference.
+  static void RenderFrameDeleted(content::RenderFrameHost* rfh);
+
+  // Mark RenderFrameHost as disposed and to no longer access it. This can
+  // occur upon frame navigation.
+  void MarkRenderFrameDisposed();
+
+  // gin::Wrappable
+  static gin::WrapperInfo kWrapperInfo;
+  gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+  const char* GetTypeName() override;
+
+ protected:
+  explicit WebFrameMain(content::RenderFrameHost* render_frame);
+  ~WebFrameMain() override;
+
+ private:
+  // WebFrameMain can outlive its RenderFrameHost pointer so we need to check
+  // whether its been disposed of prior to accessing it.
+  bool CheckRenderFrame() const;
+
+  v8::Local<v8::Promise> ExecuteJavaScript(gin::Arguments* args,
+                                           const base::string16& code);
+  bool Reload(v8::Isolate* isolate);
+
+  int FrameTreeNodeID(v8::Isolate* isolate) const;
+  int ProcessID(v8::Isolate* isolate) const;
+  int RoutingID(v8::Isolate* isolate) const;
+  GURL URL(v8::Isolate* isolate) const;
+
+  content::RenderFrameHost* Top(v8::Isolate* isolate) const;
+  content::RenderFrameHost* Parent(v8::Isolate* isolate) const;
+  std::vector<content::RenderFrameHost*> Frames(v8::Isolate* isolate) const;
+  std::vector<content::RenderFrameHost*> FramesInSubtree(
+      v8::Isolate* isolate) const;
+
+  content::RenderFrameHost* render_frame_ = nullptr;
+
+  // Whether the RenderFrameHost has been removed and that it should no longer
+  // be accessed.
+  bool render_frame_disposed_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(WebFrameMain);
+};
+
+}  // namespace api
+
+}  // namespace electron
+
+#endif  // SHELL_BROWSER_API_ELECTRON_API_WEB_FRAME_MAIN_H_

shell/common/gin_converters/frame_converter.cc

@@ -0,0 +1,28 @@
+// Copyright (c) 2020 Samuel Maddock <sam@samuelmaddock.com>.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "shell/common/gin_converters/frame_converter.h"
+
+#include <string>
+#include <vector>
+
+#include "content/public/browser/render_frame_host.h"
+#include "shell/browser/api/electron_api_web_frame_main.h"
+#include "shell/common/gin_converters/blink_converter.h"
+#include "shell/common/gin_converters/callback_converter.h"
+#include "shell/common/gin_converters/gurl_converter.h"
+#include "shell/common/gin_helper/dictionary.h"
+
+namespace gin {
+
+// static
+v8::Local<v8::Value> Converter<content::RenderFrameHost*>::ToV8(
+    v8::Isolate* isolate,
+    content::RenderFrameHost* val) {
+  if (!val)
+    return v8::Null(isolate);
+  return electron::api::WebFrameMain::From(isolate, val).ToV8();
+}
+
+}  // namespace gin

shell/common/gin_converters/frame_converter.h

@@ -0,0 +1,26 @@
+// Copyright (c) 2020 Samuel Maddock <sam@samuelmaddock.com>.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef SHELL_COMMON_GIN_CONVERTERS_FRAME_CONVERTER_H_
+#define SHELL_COMMON_GIN_CONVERTERS_FRAME_CONVERTER_H_
+
+#include <utility>
+
+#include "gin/converter.h"
+
+namespace content {
+class RenderFrameHost;
+}  // namespace content
+
+namespace gin {
+
+template <>
+struct Converter<content::RenderFrameHost*> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   content::RenderFrameHost* val);
+};
+
+}  // namespace gin
+
+#endif  // SHELL_COMMON_GIN_CONVERTERS_FRAME_CONVERTER_H_

shell/common/node_bindings.cc

@@ -63,6 +63,7 @@
   V(electron_browser_view)               \
   V(electron_browser_web_contents)       \
   V(electron_browser_web_contents_view)  \
+  V(electron_browser_web_frame_main)     \
   V(electron_browser_web_view_manager)   \
   V(electron_browser_window)             \
   V(electron_common_asar)                \