build: add enable_remote_module build flag (#19821)

shell/common/api/remote/object_life_monitor.cc

@@ -0,0 +1,41 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Copyright (c) 2012 Intel Corp. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "shell/common/api/remote/object_life_monitor.h"
+
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
+
+namespace electron {
+
+ObjectLifeMonitor::ObjectLifeMonitor(v8::Isolate* isolate,
+                                     v8::Local<v8::Object> target)
+    : target_(isolate, target), weak_ptr_factory_(this) {
+  target_.SetWeak(this, OnObjectGC, v8::WeakCallbackType::kParameter);
+}
+
+ObjectLifeMonitor::~ObjectLifeMonitor() {
+  if (target_.IsEmpty())
+    return;
+  target_.ClearWeak();
+  target_.Reset();
+}
+
+// static
+void ObjectLifeMonitor::OnObjectGC(
+    const v8::WeakCallbackInfo<ObjectLifeMonitor>& data) {
+  ObjectLifeMonitor* self = data.GetParameter();
+  self->target_.Reset();
+  self->RunDestructor();
+  data.SetSecondPassCallback(Free);
+}
+
+// static
+void ObjectLifeMonitor::Free(
+    const v8::WeakCallbackInfo<ObjectLifeMonitor>& data) {
+  delete data.GetParameter();
+}
+
+}  // namespace electron

shell/common/api/remote/object_life_monitor.h

@@ -0,0 +1,34 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef SHELL_COMMON_API_REMOTE_OBJECT_LIFE_MONITOR_H_
+#define SHELL_COMMON_API_REMOTE_OBJECT_LIFE_MONITOR_H_
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "v8/include/v8.h"
+
+namespace electron {
+
+class ObjectLifeMonitor {
+ protected:
+  ObjectLifeMonitor(v8::Isolate* isolate, v8::Local<v8::Object> target);
+  virtual ~ObjectLifeMonitor();
+
+  virtual void RunDestructor() = 0;
+
+ private:
+  static void OnObjectGC(const v8::WeakCallbackInfo<ObjectLifeMonitor>& data);
+  static void Free(const v8::WeakCallbackInfo<ObjectLifeMonitor>& data);
+
+  v8::Global<v8::Object> target_;
+
+  base::WeakPtrFactory<ObjectLifeMonitor> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ObjectLifeMonitor);
+};
+
+}  // namespace electron
+
+#endif  // SHELL_COMMON_API_REMOTE_OBJECT_LIFE_MONITOR_H_

shell/common/api/remote/remote_callback_freer.cc

@@ -0,0 +1,59 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "shell/common/api/remote/remote_callback_freer.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
+#include "electron/shell/common/api/api.mojom.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
+
+namespace electron {
+
+// static
+void RemoteCallbackFreer::BindTo(v8::Isolate* isolate,
+                                 v8::Local<v8::Object> target,
+                                 const std::string& context_id,
+                                 int object_id,
+                                 content::WebContents* web_contents) {
+  new RemoteCallbackFreer(isolate, target, context_id, object_id, web_contents);
+}
+
+RemoteCallbackFreer::RemoteCallbackFreer(v8::Isolate* isolate,
+                                         v8::Local<v8::Object> target,
+                                         const std::string& context_id,
+                                         int object_id,
+                                         content::WebContents* web_contents)
+    : ObjectLifeMonitor(isolate, target),
+      content::WebContentsObserver(web_contents),
+      context_id_(context_id),
+      object_id_(object_id) {}
+
+RemoteCallbackFreer::~RemoteCallbackFreer() = default;
+
+void RemoteCallbackFreer::RunDestructor() {
+  auto* channel = "ELECTRON_RENDERER_RELEASE_CALLBACK";
+  base::ListValue args;
+  int32_t sender_id = 0;
+  args.AppendString(context_id_);
+  args.AppendInteger(object_id_);
+  auto* frame_host = web_contents()->GetMainFrame();
+  if (frame_host) {
+    mojom::ElectronRendererAssociatedPtr electron_ptr;
+    frame_host->GetRemoteAssociatedInterfaces()->GetInterface(
+        mojo::MakeRequest(&electron_ptr));
+    electron_ptr->Message(true /* internal */, false /* send_to_all */, channel,
+                          args.Clone(), sender_id);
+  }
+
+  Observe(nullptr);
+}
+
+void RemoteCallbackFreer::RenderViewDeleted(content::RenderViewHost*) {
+  delete this;
+}
+
+}  // namespace electron

shell/common/api/remote/remote_callback_freer.h

@@ -0,0 +1,46 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef SHELL_COMMON_API_REMOTE_REMOTE_CALLBACK_FREER_H_
+#define SHELL_COMMON_API_REMOTE_REMOTE_CALLBACK_FREER_H_
+
+#include <string>
+
+#include "content/public/browser/web_contents_observer.h"
+#include "shell/common/api/remote/object_life_monitor.h"
+
+namespace electron {
+
+class RemoteCallbackFreer : public ObjectLifeMonitor,
+                            public content::WebContentsObserver {
+ public:
+  static void BindTo(v8::Isolate* isolate,
+                     v8::Local<v8::Object> target,
+                     const std::string& context_id,
+                     int object_id,
+                     content::WebContents* web_conents);
+
+ protected:
+  RemoteCallbackFreer(v8::Isolate* isolate,
+                      v8::Local<v8::Object> target,
+                      const std::string& context_id,
+                      int object_id,
+                      content::WebContents* web_conents);
+  ~RemoteCallbackFreer() override;
+
+  void RunDestructor() override;
+
+  // content::WebContentsObserver:
+  void RenderViewDeleted(content::RenderViewHost*) override;
+
+ private:
+  std::string context_id_;
+  int object_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoteCallbackFreer);
+};
+
+}  // namespace electron
+
+#endif  // SHELL_COMMON_API_REMOTE_REMOTE_CALLBACK_FREER_H_

shell/common/api/remote/remote_object_freer.cc

@@ -0,0 +1,96 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "shell/common/api/remote/remote_object_freer.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
+#include "content/public/renderer/render_frame.h"
+#include "electron/shell/common/api/api.mojom.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
+#include "third_party/blink/public/web/web_local_frame.h"
+
+using blink::WebLocalFrame;
+
+namespace electron {
+
+namespace {
+
+content::RenderFrame* GetCurrentRenderFrame() {
+  WebLocalFrame* frame = WebLocalFrame::FrameForCurrentContext();
+  if (!frame)
+    return nullptr;
+
+  return content::RenderFrame::FromWebFrame(frame);
+}
+
+}  // namespace
+
+// static
+void RemoteObjectFreer::BindTo(v8::Isolate* isolate,
+                               v8::Local<v8::Object> target,
+                               const std::string& context_id,
+                               int object_id) {
+  new RemoteObjectFreer(isolate, target, context_id, object_id);
+}
+
+// static
+void RemoteObjectFreer::AddRef(const std::string& context_id, int object_id) {
+  ref_mapper_[context_id][object_id]++;
+}
+
+// static
+std::map<std::string, std::map<int, int>> RemoteObjectFreer::ref_mapper_;
+
+RemoteObjectFreer::RemoteObjectFreer(v8::Isolate* isolate,
+                                     v8::Local<v8::Object> target,
+                                     const std::string& context_id,
+                                     int object_id)
+    : ObjectLifeMonitor(isolate, target),
+      context_id_(context_id),
+      object_id_(object_id),
+      routing_id_(MSG_ROUTING_NONE) {
+  content::RenderFrame* render_frame = GetCurrentRenderFrame();
+  if (render_frame) {
+    routing_id_ = render_frame->GetRoutingID();
+  }
+}
+
+RemoteObjectFreer::~RemoteObjectFreer() = default;
+
+void RemoteObjectFreer::RunDestructor() {
+  content::RenderFrame* render_frame =
+      content::RenderFrame::FromRoutingID(routing_id_);
+  if (!render_frame)
+    return;
+
+  // Reset our local ref count in case we are in a GC race condition
+  // and will get more references in an inbound IPC message
+  int ref_count = 0;
+  const auto objects_it = ref_mapper_.find(context_id_);
+  if (objects_it != std::end(ref_mapper_)) {
+    auto& objects = objects_it->second;
+    const auto ref_it = objects.find(object_id_);
+    if (ref_it != std::end(objects)) {
+      ref_count = ref_it->second;
+      objects.erase(ref_it);
+    }
+    if (objects.empty())
+      ref_mapper_.erase(objects_it);
+  }
+
+  auto* channel = "ELECTRON_BROWSER_DEREFERENCE";
+
+  base::ListValue args;
+  args.AppendString(context_id_);
+  args.AppendInteger(object_id_);
+  args.AppendInteger(ref_count);
+
+  mojom::ElectronBrowserAssociatedPtr electron_ptr;
+  render_frame->GetRemoteAssociatedInterfaces()->GetInterface(
+      mojo::MakeRequest(&electron_ptr));
+  electron_ptr->Message(true, channel, args.Clone());
+}
+
+}  // namespace electron

shell/common/api/remote/remote_object_freer.h

@@ -0,0 +1,45 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef SHELL_COMMON_API_REMOTE_REMOTE_OBJECT_FREER_H_
+#define SHELL_COMMON_API_REMOTE_REMOTE_OBJECT_FREER_H_
+
+#include <map>
+#include <string>
+
+#include "shell/common/api/remote/object_life_monitor.h"
+
+namespace electron {
+
+class RemoteObjectFreer : public ObjectLifeMonitor {
+ public:
+  static void BindTo(v8::Isolate* isolate,
+                     v8::Local<v8::Object> target,
+                     const std::string& context_id,
+                     int object_id);
+  static void AddRef(const std::string& context_id, int object_id);
+
+ protected:
+  RemoteObjectFreer(v8::Isolate* isolate,
+                    v8::Local<v8::Object> target,
+                    const std::string& context_id,
+                    int object_id);
+  ~RemoteObjectFreer() override;
+
+  void RunDestructor() override;
+
+  // { context_id => { object_id => ref_count }}
+  static std::map<std::string, std::map<int, int>> ref_mapper_;
+
+ private:
+  std::string context_id_;
+  int object_id_;
+  int routing_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoteObjectFreer);
+};
+
+}  // namespace electron
+
+#endif  // SHELL_COMMON_API_REMOTE_REMOTE_OBJECT_FREER_H_