Convert devtools_agent.mojom to new Mojo types

This CL converts DevToolsSessionHost and DevToolsSession
to new Mojo types.

The changes are two CLs and it is the first CL and the
second on is [1].

It updates AttachDevToolsSession and ChildWorkerCreated
from devtools_agent.mojom

It also converted methods and members which take these
DevToolsAgent and DevToolsAgentHost to new Mojo types.

SharedWorkerDevToolsAgentHost::WorkerReadyForInspection
and ServiceWorkerDevToolsAgentHost::WorkerReadyForInspection
still keep old types and these are handled at [1] with
the rest of code which still uses old types.

[1] https://crrev.com/c/1748906

Bug: 955171, 978694
Change-Id: I2d67a390b3299bfd71d4539857973481f349849e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1745944Reviewed-by: Ken Rockot <rockot@google.com>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Commit-Queue: Julie Kim <jkim@igalia.com>
Cr-Commit-Position: refs/heads/master@{#686352}

content/browser/devtools/devtools_renderer_channel.cc

@@ -19,41 +19,51 @@ namespace content {
 
 DevToolsRendererChannel::DevToolsRendererChannel(DevToolsAgentHostImpl* owner)
     : owner_(owner),
-      binding_(this),
-      associated_binding_(this),
       process_id_(ChildProcessHost::kInvalidUniqueID) {}
 
 DevToolsRendererChannel::~DevToolsRendererChannel() = default;
 
 void DevToolsRendererChannel::SetRenderer(
-    blink::mojom::DevToolsAgentPtr agent_ptr,
-    blink::mojom::DevToolsAgentHostRequest host_request,
+    mojo::PendingRemote<blink::mojom::DevToolsAgent> agent_remote,
+    mojo::PendingReceiver<blink::mojom::DevToolsAgentHost> host_receiver,
     int process_id,
-    RenderFrameHostImpl* frame_host) {
+    RenderFrameHostImpl* frame_host,
+    base::OnceClosure connection_error) {
   CleanupConnection();
-  agent_ptr_ = std::move(agent_ptr);
-  if (host_request)
-    binding_.Bind(std::move(host_request));
-  SetRendererInternal(agent_ptr_.get(), process_id, frame_host);
+  blink::mojom::DevToolsAgent* agent = nullptr;
+  if (agent_remote.is_valid()) {
+    agent_remote_.Bind(std::move(agent_remote));
+    agent = agent_remote_.get();
+  }
+  if (connection_error)
+    agent_remote_.set_disconnect_handler(std::move(connection_error));
+  if (host_receiver)
+    receiver_.Bind(std::move(host_receiver));
+  SetRendererInternal(agent, process_id, frame_host);
 }
 
 void DevToolsRendererChannel::SetRendererAssociated(
-    blink::mojom::DevToolsAgentAssociatedPtr agent_ptr,
-    blink::mojom::DevToolsAgentHostAssociatedRequest host_request,
+    mojo::PendingAssociatedRemote<blink::mojom::DevToolsAgent> agent_remote,
+    mojo::PendingAssociatedReceiver<blink::mojom::DevToolsAgentHost>
+        host_receiver,
     int process_id,
     RenderFrameHostImpl* frame_host) {
   CleanupConnection();
-  associated_agent_ptr_ = std::move(agent_ptr);
-  if (host_request)
-    associated_binding_.Bind(std::move(host_request));
-  SetRendererInternal(associated_agent_ptr_.get(), process_id, frame_host);
+  blink::mojom::DevToolsAgent* agent = nullptr;
+  if (agent_remote.is_valid()) {
+    associated_agent_remote_.Bind(std::move(agent_remote));
+    agent = associated_agent_remote_.get();
+  }
+  if (host_receiver)
+    associated_receiver_.Bind(std::move(host_receiver));
+  SetRendererInternal(agent, process_id, frame_host);
 }
 
 void DevToolsRendererChannel::CleanupConnection() {
-  binding_.Close();
-  associated_binding_.Close();
-  associated_agent_ptr_ = nullptr;
-  agent_ptr_ = nullptr;
+  receiver_.reset();
+  associated_receiver_.reset();
+  associated_agent_remote_.reset();
+  agent_remote_.reset();
 }
 
 void DevToolsRendererChannel::ForceDetachWorkerSessions() {
@@ -81,25 +91,25 @@ void DevToolsRendererChannel::SetRendererInternal(
 }
 
 void DevToolsRendererChannel::AttachSession(DevToolsSession* session) {
-  if (!agent_ptr_ && !associated_agent_ptr_)
+  if (!agent_remote_ && !associated_agent_remote_)
     owner_->UpdateRendererChannel(true /* force */);
   for (auto& pair : session->handlers())
     pair.second->SetRenderer(process_id_, frame_host_);
-  if (agent_ptr_)
-    session->AttachToAgent(agent_ptr_.get());
-  else if (associated_agent_ptr_)
-    session->AttachToAgent(associated_agent_ptr_.get());
+  if (agent_remote_)
+    session->AttachToAgent(agent_remote_.get());
+  else if (associated_agent_remote_)
+    session->AttachToAgent(associated_agent_remote_.get());
 }
 
 void DevToolsRendererChannel::InspectElement(const gfx::Point& point) {
-  if (!agent_ptr_ && !associated_agent_ptr_)
+  if (!agent_remote_ && !associated_agent_remote_)
     owner_->UpdateRendererChannel(true /* force */);
-  // Previous call might update |agent_ptr_| or |associated_agent_ptr_|
+  // Previous call might update |agent_remote_| or |associated_agent_remote_|
   // via SetRenderer(), so we should check them again.
-  if (agent_ptr_)
-    agent_ptr_->InspectElement(point);
-  else if (associated_agent_ptr_)
-    associated_agent_ptr_->InspectElement(point);
+  if (agent_remote_)
+    agent_remote_->InspectElement(point);
+  else if (associated_agent_remote_)
+    associated_agent_remote_->InspectElement(point);
 }
 
 void DevToolsRendererChannel::SetReportChildWorkers(
@@ -122,13 +132,13 @@ void DevToolsRendererChannel::SetReportChildWorkers(
     wait_for_debugger_attachers_.insert(attacher);
   else
     wait_for_debugger_attachers_.erase(attacher);
-  if (agent_ptr_) {
-    agent_ptr_->ReportChildWorkers(
+  if (agent_remote_) {
+    agent_remote_->ReportChildWorkers(
         !report_attachers_.empty(), !wait_for_debugger_attachers_.empty(),
         base::BindOnce(&DevToolsRendererChannel::ReportChildWorkersCallback,
                        base::Unretained(this)));
-  } else if (associated_agent_ptr_) {
-    associated_agent_ptr_->ReportChildWorkers(
+  } else if (associated_agent_remote_) {
+    associated_agent_remote_->ReportChildWorkers(
         !report_attachers_.empty(), !wait_for_debugger_attachers_.empty(),
         base::BindOnce(&DevToolsRendererChannel::ReportChildWorkersCallback,
                        base::Unretained(this)));
@@ -143,8 +153,8 @@ void DevToolsRendererChannel::ReportChildWorkersCallback() {
 }
 
 void DevToolsRendererChannel::ChildWorkerCreated(
-    blink::mojom::DevToolsAgentPtr worker_devtools_agent,
-    blink::mojom::DevToolsAgentHostRequest host_request,
+    mojo::PendingRemote<blink::mojom::DevToolsAgent> worker_devtools_agent,
+    mojo::PendingReceiver<blink::mojom::DevToolsAgentHost> host_receiver,
     const GURL& url,
     const std::string& name,
     const base::UnguessableToken& devtools_worker_token,
@@ -159,7 +169,7 @@ void DevToolsRendererChannel::ChildWorkerCreated(
   GURL filtered_url = url;
   process->FilterURL(true /* empty_allowed */, &filtered_url);
   auto agent_host = base::MakeRefCounted<WorkerDevToolsAgentHost>(
-      process_id_, std::move(worker_devtools_agent), std::move(host_request),
+      process_id_, std::move(worker_devtools_agent), std::move(host_receiver),
       filtered_url, std::move(name), devtools_worker_token, owner_->GetId(),
       base::BindOnce(&DevToolsRendererChannel::ChildWorkerDestroyed,
                      weak_factory_.GetWeakPtr()));

content/browser/devtools/devtools_renderer_channel.h

@@ -10,8 +10,10 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "content/common/content_export.h"
-#include "mojo/public/cpp/bindings/associated_binding.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/associated_receiver.h"
+#include "mojo/public/cpp/bindings/associated_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "third_party/blink/public/mojom/devtools/devtools_agent.mojom.h"
 
 namespace gfx {
@@ -44,13 +46,16 @@ class CONTENT_EXPORT DevToolsRendererChannel
   // Dedicated workers use non-associated version,
   // while frames and other workers use DevToolsAgent associated
   // with respective control interfraces. See mojom for details.
-  void SetRenderer(blink::mojom::DevToolsAgentPtr agent_ptr,
-                   blink::mojom::DevToolsAgentHostRequest host_request,
-                   int process_id,
-                   RenderFrameHostImpl* frame_host);
+  void SetRenderer(
+      mojo::PendingRemote<blink::mojom::DevToolsAgent> agent_remote,
+      mojo::PendingReceiver<blink::mojom::DevToolsAgentHost> host_receiver,
+      int process_id,
+      RenderFrameHostImpl* frame_host,
+      base::OnceClosure connection_error = base::NullCallback());
   void SetRendererAssociated(
-      blink::mojom::DevToolsAgentAssociatedPtr agent_ptr,
-      blink::mojom::DevToolsAgentHostAssociatedRequest host_request,
+      mojo::PendingAssociatedRemote<blink::mojom::DevToolsAgent> agent_remote,
+      mojo::PendingAssociatedReceiver<blink::mojom::DevToolsAgentHost>
+          host_receiver,
       int process_id,
       RenderFrameHostImpl* frame_host);
   void AttachSession(DevToolsSession* session);
@@ -64,12 +69,13 @@ class CONTENT_EXPORT DevToolsRendererChannel
 
  private:
   // blink::mojom::DevToolsAgentHost implementation.
-  void ChildWorkerCreated(blink::mojom::DevToolsAgentPtr worker_devtools_agent,
-                          blink::mojom::DevToolsAgentHostRequest host_request,
-                          const GURL& url,
-                          const std::string& name,
-                          const base::UnguessableToken& devtools_worker_token,
-                          bool waiting_for_debugger) override;
+  void ChildWorkerCreated(
+      mojo::PendingRemote<blink::mojom::DevToolsAgent> worker_devtools_agent,
+      mojo::PendingReceiver<blink::mojom::DevToolsAgentHost> host_receiver,
+      const GURL& url,
+      const std::string& name,
+      const base::UnguessableToken& devtools_worker_token,
+      bool waiting_for_debugger) override;
   void ChildWorkerDestroyed(DevToolsAgentHostImpl*);
 
   void CleanupConnection();
@@ -79,10 +85,11 @@ class CONTENT_EXPORT DevToolsRendererChannel
   void ReportChildWorkersCallback();
 
   DevToolsAgentHostImpl* owner_;
-  mojo::Binding<blink::mojom::DevToolsAgentHost> binding_;
-  mojo::AssociatedBinding<blink::mojom::DevToolsAgentHost> associated_binding_;
-  blink::mojom::DevToolsAgentPtr agent_ptr_;
-  blink::mojom::DevToolsAgentAssociatedPtr associated_agent_ptr_;
+  mojo::Receiver<blink::mojom::DevToolsAgentHost> receiver_{this};
+  mojo::AssociatedReceiver<blink::mojom::DevToolsAgentHost>
+      associated_receiver_{this};
+  mojo::Remote<blink::mojom::DevToolsAgent> agent_remote_;
+  mojo::AssociatedRemote<blink::mojom::DevToolsAgent> associated_agent_remote_;
   int process_id_;
   RenderFrameHostImpl* frame_host_ = nullptr;
   base::flat_set<protocol::TargetAutoAttacher*> report_attachers_;

content/browser/devtools/devtools_session.cc

@@ -44,9 +44,7 @@ static const char kSessionId[] = "sessionId";
 }  // namespace
 
 DevToolsSession::DevToolsSession(DevToolsAgentHostClient* client)
-    : binding_(this),
-      client_(client),
-      dispatcher_(new protocol::UberDispatcher(this)) {}
+    : client_(client), dispatcher_(new protocol::UberDispatcher(this)) {}
 
 DevToolsSession::~DevToolsSession() {
   if (proxy_delegate_)
@@ -98,19 +96,26 @@ void DevToolsSession::TurnIntoExternalProxy(
 void DevToolsSession::AttachToAgent(blink::mojom::DevToolsAgent* agent) {
   DCHECK(agent_host_);
   if (!agent) {
-    binding_.Close();
-    session_ptr_.reset();
-    io_session_ptr_.reset();
+    receiver_.reset();
+    session_.reset();
+    io_session_.reset();
     return;
   }
 
-  blink::mojom::DevToolsSessionHostAssociatedPtrInfo host_ptr_info;
-  binding_.Bind(mojo::MakeRequest(&host_ptr_info));
-  agent->AttachDevToolsSession(
-      std::move(host_ptr_info), mojo::MakeRequest(&session_ptr_),
-      mojo::MakeRequest(&io_session_ptr_), session_state_cookie_.Clone(),
-      client_->UsesBinaryProtocol());
-  session_ptr_.set_connection_error_handler(base::BindOnce(
+  // TODO(https://crbug.com/978694): Consider a reset flow since new mojo types
+  // checks is_bound strictly.
+  if (receiver_.is_bound()) {
+    receiver_.reset();
+    session_.reset();
+    io_session_.reset();
+  }
+
+  agent->AttachDevToolsSession(receiver_.BindNewEndpointAndPassRemote(),
+                               session_.BindNewEndpointAndPassReceiver(),
+                               io_session_.BindNewPipeAndPassReceiver(),
+                               session_state_cookie_.Clone(),
+                               client_->UsesBinaryProtocol());
+  session_.set_disconnect_handler(base::BindOnce(
       &DevToolsSession::MojoConnectionDestroyed, base::Unretained(this)));
 
   if (!suspended_sending_messages_to_agent_) {
@@ -134,9 +139,9 @@ void DevToolsSession::AttachToAgent(blink::mojom::DevToolsAgent* agent) {
 }
 
 void DevToolsSession::MojoConnectionDestroyed() {
-  binding_.Close();
-  session_ptr_.reset();
-  io_session_ptr_.reset();
+  receiver_.reset();
+  session_.reset();
+  io_session_.reset();
 }
 
 // The client of the devtools session will call this method to send a message
@@ -245,13 +250,13 @@ void DevToolsSession::DispatchProtocolMessageToAgent(
   message_ptr->data = mojo_base::BigBuffer(base::make_span(
       reinterpret_cast<const uint8_t*>(message.data()), message.length()));
   if (ShouldSendOnIO(method)) {
-    if (io_session_ptr_)
-      io_session_ptr_->DispatchProtocolCommand(call_id, method,
-                                               std::move(message_ptr));
+    if (io_session_)
+      io_session_->DispatchProtocolCommand(call_id, method,
+                                           std::move(message_ptr));
   } else {
-    if (session_ptr_)
-      session_ptr_->DispatchProtocolCommand(call_id, method,
-                                            std::move(message_ptr));
+    if (session_)
+      session_->DispatchProtocolCommand(call_id, method,
+                                        std::move(message_ptr));
   }
 }
 

content/browser/devtools/devtools_session.h

@@ -15,7 +15,9 @@
 #include "base/values.h"
 #include "content/browser/devtools/protocol/forward.h"
 #include "content/public/browser/devtools_external_agent_proxy.h"
-#include "mojo/public/cpp/bindings/associated_binding.h"
+#include "mojo/public/cpp/bindings/associated_receiver.h"
+#include "mojo/public/cpp/bindings/associated_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "third_party/blink/public/mojom/devtools/devtools_agent.mojom.h"
 
 namespace content {
@@ -103,9 +105,9 @@ class DevToolsSession : public protocol::FrontendChannel,
   // Merges the |updates| received from the renderer into session_state_cookie_.
   void ApplySessionStateUpdates(blink::mojom::DevToolsSessionStatePtr updates);
 
-  mojo::AssociatedBinding<blink::mojom::DevToolsSessionHost> binding_;
-  blink::mojom::DevToolsSessionAssociatedPtr session_ptr_;
-  blink::mojom::DevToolsSessionPtr io_session_ptr_;
+  mojo::AssociatedReceiver<blink::mojom::DevToolsSessionHost> receiver_{this};
+  mojo::AssociatedRemote<blink::mojom::DevToolsSession> session_;
+  mojo::Remote<blink::mojom::DevToolsSession> io_session_;
   DevToolsAgentHostImpl* agent_host_ = nullptr;
   DevToolsAgentHostClient* client_;
   bool browser_only_ = false;

content/browser/devtools/render_frame_devtools_agent_host.cc

@@ -755,18 +755,21 @@ void RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame(
 }
 
 void RenderFrameDevToolsAgentHost::UpdateRendererChannel(bool force) {
-  blink::mojom::DevToolsAgentAssociatedPtr agent_ptr;
-  blink::mojom::DevToolsAgentHostAssociatedRequest host_request;
+  mojo::PendingAssociatedRemote<blink::mojom::DevToolsAgent> agent_remote;
+  mojo::PendingAssociatedReceiver<blink::mojom::DevToolsAgentHost>
+      host_receiver;
   if (frame_host_ && render_frame_alive_ && force) {
-    blink::mojom::DevToolsAgentHostAssociatedPtrInfo host_ptr_info;
-    host_request = mojo::MakeRequest(&host_ptr_info);
-    frame_host_->BindDevToolsAgent(std::move(host_ptr_info),
-                                   mojo::MakeRequest(&agent_ptr));
+    mojo::PendingAssociatedRemote<blink::mojom::DevToolsAgentHost> host_remote;
+    host_receiver = host_remote.InitWithNewEndpointAndPassReceiver();
+    frame_host_->BindDevToolsAgent(
+        std::move(host_remote),
+        agent_remote.InitWithNewEndpointAndPassReceiver());
   }
   int process_id = frame_host_ ? frame_host_->GetProcess()->GetID()
                                : ChildProcessHost::kInvalidUniqueID;
-  GetRendererChannel()->SetRendererAssociated(
-      std::move(agent_ptr), std::move(host_request), process_id, frame_host_);
+  GetRendererChannel()->SetRendererAssociated(std::move(agent_remote),
+                                              std::move(host_receiver),
+                                              process_id, frame_host_);
 }
 
 bool RenderFrameDevToolsAgentHost::IsChildFrame() {

content/browser/devtools/service_worker_devtools_agent_host.cc

@@ -164,9 +164,7 @@ void ServiceWorkerDevToolsAgentHost::WorkerReadyForInspection(
     blink::mojom::DevToolsAgentHostRequest host_request) {
   DCHECK_EQ(WORKER_NOT_READY, state_);
   state_ = WORKER_READY;
-  blink::mojom::DevToolsAgentPtr agent_ptr;
-  agent_ptr.Bind(std::move(agent_ptr_info));
-  GetRendererChannel()->SetRenderer(std::move(agent_ptr),
+  GetRendererChannel()->SetRenderer(std::move(agent_ptr_info),
                                     std::move(host_request), worker_process_id_,
                                     nullptr);
   for (auto* inspector : protocol::InspectorHandler::ForAgentHost(this))
@@ -188,8 +186,9 @@ void ServiceWorkerDevToolsAgentHost::WorkerDestroyed() {
   state_ = WORKER_TERMINATED;
   for (auto* inspector : protocol::InspectorHandler::ForAgentHost(this))
     inspector->TargetCrashed();
-  GetRendererChannel()->SetRenderer(
-      nullptr, nullptr, ChildProcessHost::kInvalidUniqueID, nullptr);
+  GetRendererChannel()->SetRenderer(mojo::NullRemote(), mojo::NullReceiver(),
+                                    ChildProcessHost::kInvalidUniqueID,
+                                    nullptr);
   if (!sessions().empty())
     UpdateIsAttached(false);
 }

content/browser/devtools/shared_worker_devtools_agent_host.cc

@@ -95,7 +95,7 @@ void SharedWorkerDevToolsAgentHost::WorkerReadyForInspection(
   DCHECK_EQ(WORKER_NOT_READY, state_);
   DCHECK(worker_host_);
   state_ = WORKER_READY;
-  GetRendererChannel()->SetRenderer(std::move(agent_ptr),
+  GetRendererChannel()->SetRenderer(agent_ptr.PassInterface(),
                                     std::move(agent_host_request),
                                     worker_host_->worker_process_id(), nullptr);
   for (auto* inspector : protocol::InspectorHandler::ForAgentHost(this))
@@ -117,8 +117,9 @@ void SharedWorkerDevToolsAgentHost::WorkerDestroyed() {
   for (auto* inspector : protocol::InspectorHandler::ForAgentHost(this))
     inspector->TargetCrashed();
   worker_host_ = nullptr;
-  GetRendererChannel()->SetRenderer(
-      nullptr, nullptr, ChildProcessHost::kInvalidUniqueID, nullptr);
+  GetRendererChannel()->SetRenderer(mojo::NullRemote(), mojo::NullReceiver(),
+                                    ChildProcessHost::kInvalidUniqueID,
+                                    nullptr);
 }
 
 }  // namespace content

content/browser/devtools/worker_devtools_agent_host.cc

@@ -14,8 +14,8 @@ namespace content {
 
 WorkerDevToolsAgentHost::WorkerDevToolsAgentHost(
     int process_id,
-    blink::mojom::DevToolsAgentPtr agent_ptr,
-    blink::mojom::DevToolsAgentHostRequest host_request,
+    mojo::PendingRemote<blink::mojom::DevToolsAgent> agent_remote,
+    mojo::PendingReceiver<blink::mojom::DevToolsAgentHost> host_receiver,
     const GURL& url,
     const std::string& name,
     const base::UnguessableToken& devtools_worker_token,
@@ -27,22 +27,24 @@ WorkerDevToolsAgentHost::WorkerDevToolsAgentHost(
       name_(name),
       parent_id_(parent_id),
       destroyed_callback_(std::move(destroyed_callback)) {
-  DCHECK(agent_ptr);
+  DCHECK(agent_remote);
   DCHECK(!devtools_worker_token.is_empty());
   AddRef();  // Self keep-alive while the worker agent is alive.
-  agent_ptr.set_connection_error_handler(base::BindOnce(
+  base::OnceClosure connection_error = (base::BindOnce(
       &WorkerDevToolsAgentHost::Disconnected, base::Unretained(this)));
   NotifyCreated();
-  GetRendererChannel()->SetRenderer(
-      std::move(agent_ptr), std::move(host_request), process_id, nullptr);
+  GetRendererChannel()->SetRenderer(std::move(agent_remote),
+                                    std::move(host_receiver), process_id,
+                                    nullptr, std::move(connection_error));
 }
 
 WorkerDevToolsAgentHost::~WorkerDevToolsAgentHost() {}
 
 void WorkerDevToolsAgentHost::Disconnected() {
   ForceDetachAllSessions();
-  GetRendererChannel()->SetRenderer(
-      nullptr, nullptr, ChildProcessHost::kInvalidUniqueID, nullptr);
+  GetRendererChannel()->SetRenderer(mojo::NullRemote(), mojo::NullReceiver(),
+                                    ChildProcessHost::kInvalidUniqueID,
+                                    nullptr);
   std::move(destroyed_callback_).Run(this);
   Release();  // Matches AddRef() in constructor.
 }

content/browser/devtools/worker_devtools_agent_host.h

@@ -17,8 +17,8 @@ class WorkerDevToolsAgentHost : public DevToolsAgentHostImpl {
  public:
   WorkerDevToolsAgentHost(
       int process_id,
-      blink::mojom::DevToolsAgentPtr agent_ptr,
-      blink::mojom::DevToolsAgentHostRequest host_request,
+      mojo::PendingRemote<blink::mojom::DevToolsAgent> agent_remote,
+      mojo::PendingReceiver<blink::mojom::DevToolsAgentHost> host_receiver,
       const GURL& url,
       const std::string& name,
       const base::UnguessableToken& devtools_worker_token,

third_party/blink/public/mojom/devtools/devtools_agent.mojom

@@ -72,9 +72,9 @@ interface DevToolsAgent {
   // |client_expects_binary_response| indicates that responses (and
   // notifications) sent from this session should use binary (CBOR)
   // encoding as opposed to JSON encoding.
-  AttachDevToolsSession(associated DevToolsSessionHost host,
-                        associated DevToolsSession& session,
-                        DevToolsSession& io_session,
+  AttachDevToolsSession(pending_associated_remote<DevToolsSessionHost> host,
+                        pending_associated_receiver<DevToolsSession> session,
+                        pending_receiver<DevToolsSession> io_session,
                         DevToolsSessionState? reattach_session_state,
                         bool client_expects_binary_responses);
 
@@ -102,8 +102,8 @@ interface DevToolsAgentHost {
   // |waiting_for_debugger| is true if worker was paused on startup and
   // should be resumed by debugger to actually start.
   ChildWorkerCreated(
-      DevToolsAgent worker_devtools_agent,
-      DevToolsAgentHost& worker_devtools_agent_host,
+      pending_remote<DevToolsAgent> worker_devtools_agent,
+      pending_receiver<DevToolsAgentHost> worker_devtools_agent_host,
       url.mojom.Url url,
       string name,
       mojo_base.mojom.UnguessableToken devtools_worker_token,

third_party/blink/renderer/core/exported/web_shared_worker_impl.cc

@@ -255,10 +255,12 @@ void WebSharedWorkerImpl::StartWorkerContext(
   auto devtools_params = std::make_unique<WorkerDevToolsParams>();
   devtools_params->devtools_worker_token = devtools_worker_token;
   devtools_params->wait_for_debugger = pause_worker_context_on_start;
-  mojom::blink::DevToolsAgentPtrInfo devtools_agent_ptr_info;
-  devtools_params->agent_request = mojo::MakeRequest(&devtools_agent_ptr_info);
-  mojom::blink::DevToolsAgentHostRequest devtools_agent_host_request =
-      mojo::MakeRequest(&devtools_params->agent_host_ptr_info);
+  mojo::PendingRemote<mojom::blink::DevToolsAgent> devtools_agent_remote;
+  devtools_params->agent_receiver =
+      devtools_agent_remote.InitWithNewPipeAndPassReceiver();
+  mojo::PendingReceiver<mojom::blink::DevToolsAgentHost>
+      devtools_agent_host_receiver =
+          devtools_params->agent_host_remote.InitWithNewPipeAndPassReceiver();
 
   GetWorkerThread()->Start(std::move(creation_params), thread_startup_data,
                            std::move(devtools_params));
@@ -268,9 +270,8 @@ void WebSharedWorkerImpl::StartWorkerContext(
       v8_inspector::V8StackTraceId());
 
   // We are now ready to inspect worker thread.
-  client_->WorkerReadyForInspection(
-      devtools_agent_ptr_info.PassHandle(),
-      devtools_agent_host_request.PassMessagePipe());
+  client_->WorkerReadyForInspection(devtools_agent_remote.PassPipe(),
+                                    devtools_agent_host_receiver.PassPipe());
 }
 
 void WebSharedWorkerImpl::OnAppCacheSelected() {

third_party/blink/renderer/core/inspector/devtools_agent.cc

@@ -56,8 +56,6 @@ DevToolsAgent::DevToolsAgent(
     scoped_refptr<InspectorTaskRunner> inspector_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
     : client_(client),
-      binding_(this),
-      associated_binding_(this),
       inspected_frames_(inspected_frames),
       probe_sink_(probe_sink),
       inspector_task_runner_(std::move(inspector_task_runner)),
@@ -79,39 +77,40 @@ void DevToolsAgent::Dispose() {
 }
 
 void DevToolsAgent::BindRequest(
-    mojom::blink::DevToolsAgentHostPtrInfo host_ptr_info,
-    mojom::blink::DevToolsAgentRequest request,
+    mojo::PendingRemote<mojom::blink::DevToolsAgentHost> host_remote,
+    mojo::PendingReceiver<mojom::blink::DevToolsAgent> receiver,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  DCHECK(!binding_);
-  DCHECK(!associated_binding_);
-  binding_.Bind(std::move(request), std::move(task_runner));
-  host_ptr_.Bind(std::move(host_ptr_info));
-  host_ptr_.set_connection_error_handler(
+  DCHECK(!receiver_.is_bound());
+  DCHECK(!associated_receiver_.is_bound());
+  receiver_.Bind(std::move(receiver), std::move(task_runner));
+  host_remote_.Bind(std::move(host_remote));
+  host_remote_.set_disconnect_handler(
       WTF::Bind(&DevToolsAgent::CleanupConnection, WrapWeakPersistent(this)));
 }
 
 void DevToolsAgent::BindRequest(
-    mojom::blink::DevToolsAgentHostAssociatedPtrInfo host_ptr_info,
-    mojom::blink::DevToolsAgentAssociatedRequest request,
+    mojo::PendingAssociatedRemote<mojom::blink::DevToolsAgentHost> host_remote,
+    mojo::PendingAssociatedReceiver<mojom::blink::DevToolsAgent> receiver,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  DCHECK(!binding_);
-  DCHECK(!associated_binding_);
-  associated_binding_.Bind(std::move(request), std::move(task_runner));
-  associated_host_ptr_.Bind(std::move(host_ptr_info));
-  associated_host_ptr_.set_connection_error_handler(
+  DCHECK(!receiver_.is_bound());
+  DCHECK(!associated_receiver_.is_bound());
+  associated_receiver_.Bind(std::move(receiver), std::move(task_runner));
+  associated_host_remote_.Bind(std::move(host_remote));
+  associated_host_remote_.set_disconnect_handler(
       WTF::Bind(&DevToolsAgent::CleanupConnection, WrapWeakPersistent(this)));
 }
 
 void DevToolsAgent::AttachDevToolsSession(
-    mojom::blink::DevToolsSessionHostAssociatedPtrInfo host,
-    mojom::blink::DevToolsSessionAssociatedRequest session_request,
-    mojom::blink::DevToolsSessionRequest io_session_request,
+    mojo::PendingAssociatedRemote<mojom::blink::DevToolsSessionHost> host,
+    mojo::PendingAssociatedReceiver<mojom::blink::DevToolsSession>
+        session_receiver,
+    mojo::PendingReceiver<mojom::blink::DevToolsSession> io_session_receiver,
     mojom::blink::DevToolsSessionStatePtr reattach_session_state,
     bool client_expects_binary_responses) {
   client_->DebuggerTaskStarted();
   DevToolsSession* session = MakeGarbageCollected<DevToolsSession>(
-      this, std::move(host), std::move(session_request),
-      std::move(io_session_request), std::move(reattach_session_state),
+      this, std::move(host), std::move(session_receiver),
+      std::move(io_session_receiver), std::move(reattach_session_state),
       client_expects_binary_responses);
   sessions_.insert(session);
   client_->DebuggerTaskFinished();
@@ -154,8 +153,9 @@ std::unique_ptr<WorkerDevToolsParams> DevToolsAgent::WorkerThreadCreated(
 
   auto data = std::make_unique<WorkerData>();
   data->url = url;
-  result->agent_request = mojo::MakeRequest(&data->agent_ptr);
-  data->host_request = mojo::MakeRequest(&result->agent_host_ptr_info);
+  result->agent_receiver = data->agent_remote.InitWithNewPipeAndPassReceiver();
+  data->host_receiver =
+      result->agent_host_remote.InitWithNewPipeAndPassReceiver();
   data->devtools_worker_token = result->devtools_worker_token;
   data->waiting_for_debugger = agent->pause_child_workers_on_start_;
   data->name = global_scope_name;
@@ -178,24 +178,24 @@ void DevToolsAgent::WorkerThreadTerminated(ExecutionContext* parent_context,
 }
 
 void DevToolsAgent::ReportChildWorker(std::unique_ptr<WorkerData> data) {
-  if (host_ptr_.is_bound()) {
-    host_ptr_->ChildWorkerCreated(
-        std::move(data->agent_ptr), std::move(data->host_request),
+  if (host_remote_.is_bound()) {
+    host_remote_->ChildWorkerCreated(
+        std::move(data->agent_remote), std::move(data->host_receiver),
         std::move(data->url), std::move(data->name),
         data->devtools_worker_token, data->waiting_for_debugger);
-  } else if (associated_host_ptr_.is_bound()) {
-    associated_host_ptr_->ChildWorkerCreated(
-        std::move(data->agent_ptr), std::move(data->host_request),
+  } else if (associated_host_remote_.is_bound()) {
+    associated_host_remote_->ChildWorkerCreated(
+        std::move(data->agent_remote), std::move(data->host_receiver),
         std::move(data->url), std::move(data->name),
         data->devtools_worker_token, data->waiting_for_debugger);
   }
 }
 
 void DevToolsAgent::CleanupConnection() {
-  binding_.Close();
-  associated_binding_.Close();
-  host_ptr_.reset();
-  associated_host_ptr_.reset();
+  receiver_.reset();
+  associated_receiver_.reset();
+  host_remote_.reset();
+  associated_host_remote_.reset();
   report_child_workers_ = false;
   pause_child_workers_on_start_ = false;
 }

third_party/blink/renderer/core/inspector/devtools_agent.h

@@ -9,8 +9,10 @@
 
 #include "base/single_thread_task_runner.h"
 #include "base/unguessable_token.h"
-#include "mojo/public/cpp/bindings/associated_binding.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/associated_receiver.h"
+#include "mojo/public/cpp/bindings/associated_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "third_party/blink/public/mojom/devtools/devtools_agent.mojom-blink.h"
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
@@ -58,12 +60,13 @@ class CORE_EXPORT DevToolsAgent
 
   void Dispose();
   void FlushProtocolNotifications();
-  void BindRequest(mojom::blink::DevToolsAgentHostPtrInfo,
-                   mojom::blink::DevToolsAgentRequest,
-                   scoped_refptr<base::SingleThreadTaskRunner>);
-  void BindRequest(mojom::blink::DevToolsAgentHostAssociatedPtrInfo,
-                   mojom::blink::DevToolsAgentAssociatedRequest,
+  void BindRequest(mojo::PendingRemote<mojom::blink::DevToolsAgentHost>,
+                   mojo::PendingReceiver<mojom::blink::DevToolsAgent>,
                    scoped_refptr<base::SingleThreadTaskRunner>);
+  void BindRequest(
+      mojo::PendingAssociatedRemote<mojom::blink::DevToolsAgentHost>,
+      mojo::PendingAssociatedReceiver<mojom::blink::DevToolsAgent>,
+      scoped_refptr<base::SingleThreadTaskRunner>);
   virtual void Trace(blink::Visitor*);
 
  private:
@@ -71,9 +74,10 @@ class CORE_EXPORT DevToolsAgent
 
   // mojom::blink::DevToolsAgent implementation.
   void AttachDevToolsSession(
-      mojom::blink::DevToolsSessionHostAssociatedPtrInfo,
-      mojom::blink::DevToolsSessionAssociatedRequest main_session,
-      mojom::blink::DevToolsSessionRequest io_session,
+      mojo::PendingAssociatedRemote<mojom::blink::DevToolsSessionHost>,
+      mojo::PendingAssociatedReceiver<mojom::blink::DevToolsSession>
+          main_session,
+      mojo::PendingReceiver<mojom::blink::DevToolsSession> io_session,
       mojom::blink::DevToolsSessionStatePtr reattach_session_state,
       bool client_expects_binary_responses) override;
   void InspectElement(const WebPoint& point) override;
@@ -83,8 +87,8 @@ class CORE_EXPORT DevToolsAgent
 
   struct WorkerData {
     KURL url;
-    mojom::blink::DevToolsAgentPtr agent_ptr;
-    mojom::blink::DevToolsAgentHostRequest host_request;
+    mojo::PendingRemote<mojom::blink::DevToolsAgent> agent_remote;
+    mojo::PendingReceiver<mojom::blink::DevToolsAgentHost> host_receiver;
     base::UnguessableToken devtools_worker_token;
     bool waiting_for_debugger;
     String name;
@@ -94,10 +98,12 @@ class CORE_EXPORT DevToolsAgent
   void CleanupConnection();
 
   Client* client_;
-  mojo::Binding<mojom::blink::DevToolsAgent> binding_;
-  mojo::AssociatedBinding<mojom::blink::DevToolsAgent> associated_binding_;
-  mojom::blink::DevToolsAgentHostPtr host_ptr_;
-  mojom::blink::DevToolsAgentHostAssociatedPtr associated_host_ptr_;
+  mojo::Receiver<mojom::blink::DevToolsAgent> receiver_{this};
+  mojo::AssociatedReceiver<mojom::blink::DevToolsAgent> associated_receiver_{
+      this};
+  mojo::Remote<mojom::blink::DevToolsAgentHost> host_remote_;
+  mojo::AssociatedRemote<mojom::blink::DevToolsAgentHost>
+      associated_host_remote_;
   Member<InspectedFrames> inspected_frames_;
   Member<CoreProbeSink> probe_sink_;
   HeapHashSet<Member<DevToolsSession>> sessions_;

third_party/blink/renderer/core/inspector/worker_devtools_params.h

@@ -11,8 +11,8 @@
 namespace blink {
 
 struct CORE_EXPORT WorkerDevToolsParams {
-  mojom::blink::DevToolsAgentRequest agent_request;
-  mojom::blink::DevToolsAgentHostPtrInfo agent_host_ptr_info;
+  mojo::PendingReceiver<mojom::blink::DevToolsAgent> agent_receiver;
+  mojo::PendingRemote<mojom::blink::DevToolsAgentHost> agent_host_remote;
   bool wait_for_debugger = false;
   base::UnguessableToken devtools_worker_token;
 };

third_party/blink/renderer/core/inspector/worker_inspector_controller.cc

@@ -87,8 +87,8 @@ WorkerInspectorController::WorkerInspectorController(
     agent_ = MakeGarbageCollected<DevToolsAgent>(
         this, inspected_frames_.Get(), probe_sink_.Get(),
         std::move(inspector_task_runner), std::move(io_task_runner));
-    agent_->BindRequest(std::move(devtools_params->agent_host_ptr_info),
-                        std::move(devtools_params->agent_request),
+    agent_->BindRequest(std::move(devtools_params->agent_host_remote),
+                        std::move(devtools_params->agent_receiver),
                         thread->GetTaskRunner(TaskType::kInternalInspector));
   }
   trace_event::AddEnabledStateObserver(this);

third_party/blink/renderer/modules/exported/web_embedded_worker_impl.cc

@@ -367,10 +367,12 @@ void WebEmbeddedWorkerImpl::StartWorkerThread() {
   devtools_params->devtools_worker_token = devtools_worker_token_;
   devtools_params->wait_for_debugger =
       wait_for_debugger_mode_ == WebEmbeddedWorkerStartData::kWaitForDebugger;
-  mojom::blink::DevToolsAgentPtrInfo devtools_agent_ptr_info;
-  devtools_params->agent_request = mojo::MakeRequest(&devtools_agent_ptr_info);
-  mojom::blink::DevToolsAgentHostRequest devtools_agent_host_request =
-      mojo::MakeRequest(&devtools_params->agent_host_ptr_info);
+  mojo::PendingRemote<mojom::blink::DevToolsAgent> devtools_agent_remote;
+  devtools_params->agent_receiver =
+      devtools_agent_remote.InitWithNewPipeAndPassReceiver();
+  mojo::PendingReceiver<mojom::blink::DevToolsAgentHost>
+      devtools_agent_host_receiver =
+          devtools_params->agent_host_remote.InitWithNewPipeAndPassReceiver();
 
   worker_thread_->Start(std::move(global_scope_creation_params),
                         WorkerBackingThreadStartupData::CreateDefault(),
@@ -428,8 +430,8 @@ void WebEmbeddedWorkerImpl::StartWorkerThread() {
   }
   // We are now ready to inspect worker thread.
   worker_context_client_->WorkerReadyForInspectionOnMainThread(
-      devtools_agent_ptr_info.PassHandle(),
-      devtools_agent_host_request.PassMessagePipe());
+      devtools_agent_remote.PassPipe(),
+      devtools_agent_host_receiver.PassPipe());
 }
 
 std::unique_ptr<CrossThreadFetchClientSettingsObjectData>