Cleanup usages of old mojo types and remove unused code

https://chromium-review.googlesource.com/c/chromium/src/+/2235699

shell/browser/api/electron_api_web_contents.cc

@@ -52,6 +52,8 @@
 #include "gin/object_template_builder.h"
 #include "gin/wrappable.h"
 #include "mojo/public/cpp/bindings/associated_remote.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "ppapi/buildflags/buildflags.h"
 #include "shell/browser/api/electron_api_browser_window.h"
@@ -409,7 +411,7 @@ WebContents::WebContents(v8::Isolate* isolate,
 #endif
   registry_.AddInterface(base::BindRepeating(&WebContents::BindElectronBrowser,
                                              base::Unretained(this)));
-  bindings_.set_connection_error_handler(base::BindRepeating(
+  receivers_.set_disconnect_handler(base::BindRepeating(
       &WebContents::OnElectronBrowserConnectionError, base::Unretained(this)));
 }
 
@@ -586,7 +588,7 @@ void WebContents::InitWithSessionAndOptions(
 
   registry_.AddInterface(base::BindRepeating(&WebContents::BindElectronBrowser,
                                              base::Unretained(this)));
-  bindings_.set_connection_error_handler(base::BindRepeating(
+  receivers_.set_disconnect_handler(base::BindRepeating(
       &WebContents::OnElectronBrowserConnectionError, base::Unretained(this)));
   AutofillDriverFactory::CreateForWebContents(web_contents());
 
@@ -1117,16 +1119,16 @@ bool WebContents::EmitNavigationEvent(
 }
 
 void WebContents::BindElectronBrowser(
-    mojom::ElectronBrowserRequest request,
+    mojo::PendingReceiver<mojom::ElectronBrowser> receiver,
     content::RenderFrameHost* render_frame_host) {
-  auto id = bindings_.AddBinding(this, std::move(request), render_frame_host);
-  frame_to_bindings_map_[render_frame_host].push_back(id);
+  auto id = receivers_.Add(this, std::move(receiver), render_frame_host);
+  frame_to_receivers_map_[render_frame_host].push_back(id);
 }
 
 void WebContents::OnElectronBrowserConnectionError() {
-  auto binding_id = bindings_.dispatch_binding();
-  auto* frame_host = bindings_.dispatch_context();
-  base::Erase(frame_to_bindings_map_[frame_host], binding_id);
+  auto receiver_id = receivers_.current_receiver();
+  auto* frame_host = receivers_.current_context();
+  base::Erase(frame_to_receivers_map_[frame_host], receiver_id);
 }
 
 void WebContents::Message(bool internal,
@@ -1135,7 +1137,7 @@ void WebContents::Message(bool internal,
   TRACE_EVENT1("electron", "WebContents::Message", "channel", channel);
   // webContents.emit('-ipc-message', new Event(), internal, channel,
   // arguments);
-  EmitWithSender("-ipc-message", bindings_.dispatch_context(), InvokeCallback(),
+  EmitWithSender("-ipc-message", receivers_.current_context(), InvokeCallback(),
                  internal, channel, std::move(arguments));
 }
 
@@ -1145,7 +1147,7 @@ void WebContents::Invoke(bool internal,
                          InvokeCallback callback) {
   TRACE_EVENT1("electron", "WebContents::Invoke", "channel", channel);
   // webContents.emit('-ipc-invoke', new Event(), internal, channel, arguments);
-  EmitWithSender("-ipc-invoke", bindings_.dispatch_context(),
+  EmitWithSender("-ipc-invoke", receivers_.current_context(),
                  std::move(callback), internal, channel, std::move(arguments));
 }
 
@@ -1156,7 +1158,7 @@ void WebContents::ReceivePostMessage(const std::string& channel,
       MessagePort::EntanglePorts(isolate(), std::move(message.ports));
   v8::Local<v8::Value> message_value =
       electron::DeserializeV8Value(isolate(), message);
-  EmitWithSender("-ipc-ports", bindings_.dispatch_context(), InvokeCallback(),
+  EmitWithSender("-ipc-ports", receivers_.current_context(), InvokeCallback(),
                  false, channel, message_value, std::move(wrapped_ports));
 }
 
@@ -1199,7 +1201,7 @@ void WebContents::MessageSync(bool internal,
   TRACE_EVENT1("electron", "WebContents::MessageSync", "channel", channel);
   // webContents.emit('-ipc-message-sync', new Event(sender, message), internal,
   // channel, arguments);
-  EmitWithSender("-ipc-message-sync", bindings_.dispatch_context(),
+  EmitWithSender("-ipc-message-sync", receivers_.current_context(),
                  std::move(callback), internal, channel, std::move(arguments));
 }
 
@@ -1222,7 +1224,7 @@ void WebContents::MessageHost(const std::string& channel,
                               blink::CloneableMessage arguments) {
   TRACE_EVENT1("electron", "WebContents::MessageHost", "channel", channel);
   // webContents.emit('ipc-message-host', new Event(), channel, args);
-  EmitWithSender("ipc-message-host", bindings_.dispatch_context(),
+  EmitWithSender("ipc-message-host", receivers_.current_context(),
                  InvokeCallback(), channel, std::move(arguments));
 }
 
@@ -1239,12 +1241,12 @@ void WebContents::RenderFrameDeleted(
   // that no longer exist. To prevent this from happening, when a
   // RenderFrameHost goes away, we close all the bindings related to that
   // frame.
-  auto it = frame_to_bindings_map_.find(render_frame_host);
-  if (it == frame_to_bindings_map_.end())
+  auto it = frame_to_receivers_map_.find(render_frame_host);
+  if (it == frame_to_receivers_map_.end())
     return;
   for (auto id : it->second)
-    bindings_.RemoveBinding(id);
-  frame_to_bindings_map_.erase(it);
+    receivers_.Remove(id);
+  frame_to_receivers_map_.erase(it);
 }
 
 void WebContents::DidStartNavigation(

shell/browser/api/electron_api_web_contents.h

@@ -22,7 +22,7 @@
 #include "electron/buildflags/buildflags.h"
 #include "electron/shell/common/api/api.mojom.h"
 #include "gin/handle.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
 #include "printing/buildflags/buildflags.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "shell/browser/api/frame_subscriber.h"
@@ -566,8 +566,9 @@ class WebContents : public gin_helper::TrackableObject<WebContents>,
 
   // Binds the given request for the ElectronBrowser API. When the
   // RenderFrameHost is destroyed, all related bindings will be removed.
-  void BindElectronBrowser(mojom::ElectronBrowserRequest request,
-                           content::RenderFrameHost* render_frame_host);
+  void BindElectronBrowser(
+      mojo::PendingReceiver<mojom::ElectronBrowser> receiver,
+      content::RenderFrameHost* render_frame_host);
   void OnElectronBrowserConnectionError();
 
   uint32_t GetNextRequestId() { return ++request_id_; }
@@ -649,9 +650,10 @@ class WebContents : public gin_helper::TrackableObject<WebContents>,
   int currently_committed_process_id_ = -1;
 
   service_manager::BinderRegistryWithArgs<content::RenderFrameHost*> registry_;
-  mojo::BindingSet<mojom::ElectronBrowser, content::RenderFrameHost*> bindings_;
-  std::map<content::RenderFrameHost*, std::vector<mojo::BindingId>>
-      frame_to_bindings_map_;
+  mojo::ReceiverSet<mojom::ElectronBrowser, content::RenderFrameHost*>
+      receivers_;
+  std::map<content::RenderFrameHost*, std::vector<mojo::ReceiverId>>
+      frame_to_receivers_map_;
 
   base::WeakPtrFactory<WebContents> weak_factory_;
 

shell/renderer/api/electron_api_ipc_renderer.cc

@@ -59,16 +59,16 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
     weak_context_.SetWeak();
 
     render_frame->GetRemoteInterfaces()->GetInterface(
-        mojo::MakeRequest(&electron_browser_ptr_));
+        electron_browser_remote_.BindNewPipeAndPassReceiver());
   }
 
-  void OnDestruct() override { electron_browser_ptr_.reset(); }
+  void OnDestruct() override { electron_pending_browser_.reset(); }
 
   void WillReleaseScriptContext(v8::Local<v8::Context> context,
                                 int32_t world_id) override {
     if (weak_context_.IsEmpty() ||
         weak_context_.Get(context->GetIsolate()) == context)
-      electron_browser_ptr_.reset();
+      electron_pending_browser_.reset();
   }
 
   // gin::Wrappable:
@@ -91,7 +91,7 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
                    bool internal,
                    const std::string& channel,
                    v8::Local<v8::Value> arguments) {
-    if (!electron_browser_ptr_) {
+    if (!electron_browser_remote_) {
       thrower.ThrowError(kIPCMethodCalledAfterContextReleasedError);
       return;
     }
@@ -99,7 +99,7 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
     if (!electron::SerializeV8Value(isolate, arguments, &message)) {
       return;
     }
-    electron_browser_ptr_->Message(internal, channel, std::move(message));
+    electron_browser_remote_->Message(internal, channel, std::move(message));
   }
 
   v8::Local<v8::Promise> Invoke(v8::Isolate* isolate,
@@ -107,7 +107,7 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
                                 bool internal,
                                 const std::string& channel,
                                 v8::Local<v8::Value> arguments) {
-    if (!electron_browser_ptr_) {
+    if (!electron_browser_remote_) {
       thrower.ThrowError(kIPCMethodCalledAfterContextReleasedError);
       return v8::Local<v8::Promise>();
     }
@@ -118,7 +118,7 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
     gin_helper::Promise<blink::CloneableMessage> p(isolate);
     auto handle = p.GetHandle();
 
-    electron_browser_ptr_->Invoke(
+    electron_browser_remote_->Invoke(
         internal, channel, std::move(message),
         base::BindOnce(
             [](gin_helper::Promise<blink::CloneableMessage> p,
@@ -133,7 +133,7 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
                    const std::string& channel,
                    v8::Local<v8::Value> message_value,
                    base::Optional<v8::Local<v8::Value>> transfer) {
-    if (!electron_browser_ptr_) {
+    if (!electron_browser_remote_) {
       thrower.ThrowError(kIPCMethodCalledAfterContextReleasedError);
       return;
     }
@@ -165,8 +165,8 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
     }
 
     transferable_message.ports = std::move(ports);
-    electron_browser_ptr_->ReceivePostMessage(channel,
-                                              std::move(transferable_message));
+    electron_browser_remote_->ReceivePostMessage(
+        channel, std::move(transferable_message));
   }
 
   void SendTo(v8::Isolate* isolate,
@@ -176,7 +176,7 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
               int32_t web_contents_id,
               const std::string& channel,
               v8::Local<v8::Value> arguments) {
-    if (!electron_browser_ptr_) {
+    if (!electron_browser_remote_) {
       thrower.ThrowError(kIPCMethodCalledAfterContextReleasedError);
       return;
     }
@@ -184,15 +184,15 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
     if (!electron::SerializeV8Value(isolate, arguments, &message)) {
       return;
     }
-    electron_browser_ptr_->MessageTo(internal, send_to_all, web_contents_id,
-                                     channel, std::move(message));
+    electron_browser_remote_->MessageTo(internal, send_to_all, web_contents_id,
+                                        channel, std::move(message));
   }
 
   void SendToHost(v8::Isolate* isolate,
                   gin_helper::ErrorThrower thrower,
                   const std::string& channel,
                   v8::Local<v8::Value> arguments) {
-    if (!electron_browser_ptr_) {
+    if (!electron_browser_remote_) {
       thrower.ThrowError(kIPCMethodCalledAfterContextReleasedError);
       return;
     }
@@ -200,7 +200,7 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
     if (!electron::SerializeV8Value(isolate, arguments, &message)) {
       return;
     }
-    electron_browser_ptr_->MessageHost(channel, std::move(message));
+    electron_browser_remote_->MessageHost(channel, std::move(message));
   }
 
   v8::Local<v8::Value> SendSync(v8::Isolate* isolate,
@@ -208,7 +208,7 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
                                 bool internal,
                                 const std::string& channel,
                                 v8::Local<v8::Value> arguments) {
-    if (!electron_browser_ptr_) {
+    if (!electron_browser_remote_) {
       thrower.ThrowError(kIPCMethodCalledAfterContextReleasedError);
       return v8::Local<v8::Value>();
     }
@@ -218,13 +218,13 @@ class IPCRenderer : public gin::Wrappable<IPCRenderer>,
     }
 
     blink::CloneableMessage result;
-    electron_browser_ptr_->MessageSync(internal, channel, std::move(message),
-                                       &result);
+    electron_browser_remote_->MessageSync(internal, channel, std::move(message),
+                                          &result);
     return electron::DeserializeV8Value(isolate, result);
   }
 
   v8::Global<v8::Context> weak_context_;
-  electron::mojom::ElectronBrowserPtr electron_browser_ptr_;
+  mojo::Remote<electron::mojom::ElectronBrowser> electron_browser_remote_;
 };
 
 gin::WrapperInfo IPCRenderer::kWrapperInfo = {gin::kEmbedderNativeGin};

shell/renderer/api/electron_api_web_frame.cc

@@ -270,10 +270,10 @@ void SetZoomLevel(gin_helper::ErrorThrower thrower,
     return;
   }
 
-  mojom::ElectronBrowserPtr browser_ptr;
+  mojo::Remote<mojom::ElectronBrowser> browser_remote;
   render_frame->GetRemoteInterfaces()->GetInterface(
-      mojo::MakeRequest(&browser_ptr));
-  browser_ptr->SetTemporaryZoomLevel(level);
+      browser_remote.BindPipeAndPassReceiver());
+  browser_remote->SetTemporaryZoomLevel(level);
 }
 
 double GetZoomLevel(gin_helper::ErrorThrower thrower,
@@ -287,10 +287,10 @@ double GetZoomLevel(gin_helper::ErrorThrower thrower,
     return result;
   }
 
-  mojom::ElectronBrowserPtr browser_ptr;
+  mojo::Remote<mojom::ElectronBrowser> browser_remote;
   render_frame->GetRemoteInterfaces()->GetInterface(
-      mojo::MakeRequest(&browser_ptr));
-  browser_ptr->DoGetZoomLevel(&result);
+      browser_remote.BindPipeAndPassReceiver());
+  browser_remote->DoGetZoomLevel(&result);
   return result;
 }
 

shell/renderer/electron_render_frame_observer.cc

@@ -111,10 +111,10 @@ void ElectronRenderFrameObserver::DraggableRegionsChanged() {
     regions.push_back(std::move(region));
   }
 
-  mojom::ElectronBrowserPtr browser_ptr;
+  mojo::Remote<mojom::ElectronBrowser> browser_remote;
   render_frame_->GetRemoteInterfaces()->GetInterface(
-      mojo::MakeRequest(&browser_ptr));
-  browser_ptr->UpdateDraggableRegions(std::move(regions));
+      browser_remote.BindPipeAndPassReceiver());
+  browser_remote->UpdateDraggableRegions(std::move(regions));
 }
 
 void ElectronRenderFrameObserver::WillReleaseScriptContext(