[DevTools] Make ForwardingAgentHost work with flatten protocol

Bug: 906483
Change-Id: I3da2cd45f2ab6e2d88e42c97f0de48208f210ad6
Reviewed-on: https://chromium-review.googlesource.com/c/1350966Reviewed-by: Pavel Feldman <pfeldman@chromium.org>
Commit-Queue: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#611195}

content/browser/devtools/devtools_session.cc

@@ -11,6 +11,7 @@
 #include "content/browser/devtools/protocol/protocol.h"
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/public/browser/devtools_external_agent_proxy_delegate.h"
 #include "content/public/browser/devtools_manager_delegate.h"
 
 namespace content {
@@ -52,6 +53,8 @@ DevToolsSession::DevToolsSession(DevToolsAgentHostClient* client)
       weak_factory_(this) {}
 
 DevToolsSession::~DevToolsSession() {
+  if (proxy_delegate_)
+    proxy_delegate_->Detach(this);
   // It is Ok for session to be deleted without the dispose -
   // it can be kicked out by an extension connect / disconnect.
   if (dispatcher_)
@@ -90,6 +93,12 @@ void DevToolsSession::SetBrowserOnly(bool browser_only) {
   browser_only_ = browser_only;
 }
 
+void DevToolsSession::TurnIntoExternalProxy(
+    DevToolsExternalAgentProxyDelegate* proxy_delegate) {
+  proxy_delegate_ = proxy_delegate;
+  proxy_delegate_->Attach(this);
+}
+
 void DevToolsSession::AttachToAgent(blink::mojom::DevToolsAgent* agent) {
   DCHECK(agent_host_);
   if (!agent) {
@@ -157,6 +166,11 @@ bool DevToolsSession::DispatchProtocolMessageInternal(
     std::move(runtime_resume_).Run();
   }
 
+  if (proxy_delegate_) {
+    proxy_delegate_->SendMessageToBackend(this, message);
+    return true;
+  }
+
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
   if (delegate && parsed_message) {
@@ -267,6 +281,19 @@ void DevToolsSession::DispatchProtocolNotification(
   // |this| may be deleted at this point.
 }
 
+void DevToolsSession::DispatchOnClientHost(const std::string& message) {
+  client_->DispatchProtocolMessage(agent_host_, message);
+  // |this| may be deleted at this point.
+}
+
+void DevToolsSession::ConnectionClosed() {
+  DevToolsAgentHostClient* client = client_;
+  DevToolsAgentHostImpl* agent_host = agent_host_;
+  agent_host->DetachInternal(this);
+  // |this| is delete here, do not use any fields below.
+  client->AgentHostClosed(agent_host);
+}
+
 void DevToolsSession::ApplySessionStateUpdates(
     blink::mojom::DevToolsSessionStatePtr updates) {
   if (!updates)

content/browser/devtools/devtools_session.h

@@ -12,6 +12,7 @@
 #include "base/optional.h"
 #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 "third_party/blink/public/web/devtools_agent.mojom.h"
 
@@ -19,13 +20,15 @@ namespace content {
 
 class DevToolsAgentHostClient;
 class DevToolsAgentHostImpl;
+class DevToolsExternalAgentProxyDelegate;
 
 namespace protocol {
 class DevToolsDomainHandler;
 }
 
 class DevToolsSession : public protocol::FrontendChannel,
-                        public blink::mojom::DevToolsSessionHost {
+                        public blink::mojom::DevToolsSessionHost,
+                        public DevToolsExternalAgentProxy {
  public:
   explicit DevToolsSession(DevToolsAgentHostClient* client);
   ~DevToolsSession() override;
@@ -41,6 +44,7 @@ class DevToolsSession : public protocol::FrontendChannel,
   // handle all protocol messages locally in the browser process.
   void SetBrowserOnly(bool browser_only);
   void AddHandler(std::unique_ptr<protocol::DevToolsDomainHandler> handler);
+  void TurnIntoExternalProxy(DevToolsExternalAgentProxyDelegate* delegate);
 
   void AttachToAgent(blink::mojom::DevToolsAgent* agent);
   bool DispatchProtocolMessage(const std::string& message);
@@ -91,6 +95,10 @@ class DevToolsSession : public protocol::FrontendChannel,
       const std::string& message,
       blink::mojom::DevToolsSessionStatePtr updates) override;
 
+  // DevToolsExternalAgentProxy implementation.
+  void DispatchOnClientHost(const std::string& message) override;
+  void ConnectionClosed() override;
+
   // Merges the |updates| received from the renderer into session_state_cookie_.
   void ApplySessionStateUpdates(blink::mojom::DevToolsSessionStatePtr updates);
 
@@ -128,6 +136,7 @@ class DevToolsSession : public protocol::FrontendChannel,
   DevToolsSession* root_session_ = nullptr;
   base::flat_map<std::string, DevToolsSession*> child_sessions_;
   base::OnceClosure runtime_resume_;
+  DevToolsExternalAgentProxyDelegate* proxy_delegate_ = nullptr;
 
   base::WeakPtrFactory<DevToolsSession> weak_factory_;
 };

content/browser/devtools/forwarding_agent_host.cc

@@ -4,42 +4,11 @@
 
 #include "content/browser/devtools/forwarding_agent_host.h"
 
-#include "base/bind.h"
 #include "content/browser/devtools/devtools_session.h"
-#include "content/browser/devtools/protocol/inspector_handler.h"
-#include "content/public/browser/devtools_external_agent_proxy.h"
 #include "content/public/browser/devtools_external_agent_proxy_delegate.h"
 
 namespace content {
 
-class ForwardingAgentHost::SessionProxy : public DevToolsExternalAgentProxy {
- public:
-  SessionProxy(ForwardingAgentHost* agent_host, DevToolsAgentHostClient* client)
-      : agent_host_(agent_host), client_(client) {
-    agent_host_->delegate_->Attach(this);
-  }
-
-  ~SessionProxy() override { agent_host_->delegate_->Detach(this); }
-
-  void ConnectionClosed() override {
-    DevToolsAgentHostClient* client = client_;
-    ForwardingAgentHost* agent_host = agent_host_;
-    agent_host_->session_proxies_.erase(client_);
-    // |this| is delete here, do not use any fields below.
-    client->AgentHostClosed(agent_host);
-  }
-
- private:
-  void DispatchOnClientHost(const std::string& message) override {
-    client_->DispatchProtocolMessage(agent_host_, message);
-  }
-
-  ForwardingAgentHost* agent_host_;
-  DevToolsAgentHostClient* client_;
-
-  DISALLOW_COPY_AND_ASSIGN(SessionProxy);
-};
-
 ForwardingAgentHost::ForwardingAgentHost(
     const std::string& id,
     std::unique_ptr<DevToolsExternalAgentProxyDelegate> delegate)
@@ -51,32 +20,12 @@ ForwardingAgentHost::ForwardingAgentHost(
 ForwardingAgentHost::~ForwardingAgentHost() {
 }
 
-bool ForwardingAgentHost::AttachClient(DevToolsAgentHostClient* client) {
-  session_proxies_[client].reset(new SessionProxy(this, client));
+bool ForwardingAgentHost::AttachSession(DevToolsSession* session) {
+  session->TurnIntoExternalProxy(delegate_.get());
   return true;
 }
 
-bool ForwardingAgentHost::DetachClient(DevToolsAgentHostClient* client) {
-  auto it = session_proxies_.find(client);
-  if (it == session_proxies_.end())
-    return false;
-  session_proxies_.erase(it);
-  return true;
-}
-
-bool ForwardingAgentHost::DispatchProtocolMessage(
-    DevToolsAgentHostClient* client,
-    const std::string& message) {
-  auto it = session_proxies_.find(client);
-  if (it == session_proxies_.end())
-    return false;
-  delegate_->SendMessageToBackend(it->second.get(), message);
-  return true;
-}
-
-bool ForwardingAgentHost::IsAttached() {
-  return !session_proxies_.empty();
-}
+void ForwardingAgentHost::DetachSession(DevToolsSession* session) {}
 
 std::string ForwardingAgentHost::GetType() {
   return delegate_->GetType();

content/browser/devtools/forwarding_agent_host.h

@@ -7,8 +7,6 @@
 
 #include <memory>
 
-#include "base/containers/flat_map.h"
-#include "base/memory/ref_counted.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
 
 namespace content {
@@ -22,16 +20,13 @@ class ForwardingAgentHost : public DevToolsAgentHostImpl {
       std::unique_ptr<DevToolsExternalAgentProxyDelegate> delegate);
 
  private:
-  class SessionProxy;
-
   ~ForwardingAgentHost() override;
 
-  // DevToolsAgentHost implementation
-  bool AttachClient(DevToolsAgentHostClient* client) override;
-  bool DetachClient(DevToolsAgentHostClient* client) override;
-  bool DispatchProtocolMessage(DevToolsAgentHostClient* client,
-                               const std::string& message) override;
-  bool IsAttached() override;
+  // DevToolsAgentHostImpl overrides.
+  bool AttachSession(DevToolsSession* session) override;
+  void DetachSession(DevToolsSession* session) override;
+
+  // DevToolsAgentHost implementation.
   std::string GetType() override;
   std::string GetTitle() override;
   GURL GetURL() override;
@@ -43,9 +38,6 @@ class ForwardingAgentHost : public DevToolsAgentHostImpl {
   base::TimeTicks GetLastActivityTime() override;
 
   std::unique_ptr<DevToolsExternalAgentProxyDelegate> delegate_;
-  base::flat_map<DevToolsAgentHostClient*, std::unique_ptr<SessionProxy>>
-      session_proxies_;
-
   DISALLOW_COPY_AND_ASSIGN(ForwardingAgentHost);
 };
 

third_party/blink/renderer/devtools/front_end/node_main/NodeMain.js

@@ -36,9 +36,10 @@ NodeMain.NodeChildTargetManager = class extends SDK.SDKModel {
     parentTarget.registerTargetDispatcher(this);
     this._targetAgent.setDiscoverTargets(true);
 
-    InspectorFrontendHost.setDevicesUpdatesEnabled(true);
     InspectorFrontendHost.events.addEventListener(
         InspectorFrontendHostAPI.Events.DevicesDiscoveryConfigChanged, this._devicesDiscoveryConfigChanged, this);
+    InspectorFrontendHost.setDevicesUpdatesEnabled(false);
+    InspectorFrontendHost.setDevicesUpdatesEnabled(true);
   }
 
   /**