[DevTools] Support multiple sessions in remote debugging

Bug: 590878
Change-Id: I5606ba2082e7ea81b95547b8b28f476ce3f59b43
Reviewed-on: https://chromium-review.googlesource.com/630564Reviewed-by: Ted Choc <tedchoc@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Reviewed-by: Pavel Feldman <pfeldman@chromium.org>
Commit-Queue: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#501361}

chrome/browser/android/devtools_manager_delegate_android.cc

@@ -4,6 +4,8 @@
 
 #include "chrome/browser/android/devtools_manager_delegate_android.h"
 
+#include <map>
+
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
@@ -26,19 +28,11 @@ using content::WebContents;
 
 namespace {
 
-class TabProxyDelegate : public content::DevToolsExternalAgentProxyDelegate,
-                         public content::DevToolsAgentHostClient {
+class ClientProxy : public content::DevToolsAgentHostClient {
  public:
-  explicit TabProxyDelegate(TabAndroid* tab)
-      : tab_id_(tab->GetAndroidId()),
-        title_(base::UTF16ToUTF8(tab->GetTitle())),
-        url_(tab->GetURL()),
-        agent_host_(tab->web_contents() ?
-            DevToolsAgentHost::GetOrCreateFor(tab->web_contents()) : nullptr) {
-  }
-
-  ~TabProxyDelegate() override {
-  }
+  explicit ClientProxy(content::DevToolsExternalAgentProxy* proxy)
+      : proxy_(proxy) {}
+  ~ClientProxy() override {}
 
   void DispatchProtocolMessage(DevToolsAgentHost* agent_host,
                                const std::string& message) override {
@@ -50,18 +44,39 @@ class TabProxyDelegate : public content::DevToolsExternalAgentProxyDelegate,
     proxy_->ConnectionClosed();
   }
 
+ private:
+  content::DevToolsExternalAgentProxy* proxy_;
+  DISALLOW_COPY_AND_ASSIGN(ClientProxy);
+};
+
+class TabProxyDelegate : public content::DevToolsExternalAgentProxyDelegate {
+ public:
+  explicit TabProxyDelegate(TabAndroid* tab)
+      : tab_id_(tab->GetAndroidId()),
+        title_(base::UTF16ToUTF8(tab->GetTitle())),
+        url_(tab->GetURL()),
+        agent_host_(tab->web_contents()
+                        ? DevToolsAgentHost::GetOrCreateFor(tab->web_contents())
+                        : nullptr) {}
+
+  ~TabProxyDelegate() override {}
+
   void Attach(content::DevToolsExternalAgentProxy* proxy) override {
-    proxy_ = proxy;
+    proxies_[proxy].reset(new ClientProxy(proxy));
     MaterializeAgentHost();
     if (agent_host_)
-      agent_host_->AttachClient(this);
+      agent_host_->AttachClient(proxies_[proxy].get());
   }
 
-  void Detach() override {
+  void Detach(content::DevToolsExternalAgentProxy* proxy) override {
+    auto it = proxies_.find(proxy);
+    if (it == proxies_.end())
+      return;
     if (agent_host_)
-      agent_host_->DetachClient(this);
-    agent_host_ = nullptr;
-    proxy_ = nullptr;
+      agent_host_->DetachClient(it->second.get());
+    proxies_.erase(it);
+    if (proxies_.empty())
+      agent_host_ = nullptr;
   }
 
   std::string GetType() override {
@@ -116,9 +131,13 @@ class TabProxyDelegate : public content::DevToolsExternalAgentProxyDelegate,
     return agent_host_ ? agent_host_->GetLastActivityTime() : base::TimeTicks();
   }
 
-  void SendMessageToBackend(const std::string& message) override {
+  void SendMessageToBackend(content::DevToolsExternalAgentProxy* proxy,
+                            const std::string& message) override {
+    auto it = proxies_.find(proxy);
+    if (it == proxies_.end())
+      return;
     if (agent_host_)
-      agent_host_->DispatchProtocolMessage(this, message);
+      agent_host_->DispatchProtocolMessage(it->second.get(), message);
   }
 
  private:
@@ -155,7 +174,8 @@ class TabProxyDelegate : public content::DevToolsExternalAgentProxyDelegate,
   const std::string title_;
   const GURL url_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
-  content::DevToolsExternalAgentProxy* proxy_;
+  std::map<content::DevToolsExternalAgentProxy*, std::unique_ptr<ClientProxy>>
+      proxies_;
   DISALLOW_COPY_AND_ASSIGN(TabProxyDelegate);
 };
 

chrome/browser/devtools/device/devtools_device_discovery.cc

@@ -4,6 +4,8 @@
 
 #include "chrome/browser/devtools/device/devtools_device_discovery.h"
 
+#include <map>
+
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
@@ -105,9 +107,52 @@ ProtocolCommand::~ProtocolCommand() {
 
 // AgentHostDelegate ----------------------------------------------------------
 
-class AgentHostDelegate
-    : public content::DevToolsExternalAgentProxyDelegate,
-      public AndroidDeviceManager::AndroidWebSocket::Delegate {
+class WebSocketProxy : public AndroidDeviceManager::AndroidWebSocket::Delegate {
+ public:
+  explicit WebSocketProxy(content::DevToolsExternalAgentProxy* proxy)
+      : socket_opened_(false), proxy_(proxy) {}
+
+  void WebSocketCreated(AndroidDeviceManager::AndroidWebSocket* web_socket) {
+    web_socket_.reset(web_socket);
+  }
+
+  void SendMessageToBackend(std::string message) {
+    if (socket_opened_)
+      web_socket_->SendFrame(std::move(message));
+    else
+      pending_messages_.push_back(std::move(message));
+  }
+
+  void OnSocketOpened() override {
+    socket_opened_ = true;
+    for (std::string& message : pending_messages_)
+      SendMessageToBackend(std::move(message));
+    pending_messages_.clear();
+  }
+
+  void OnFrameRead(const std::string& message) override {
+    proxy_->DispatchOnClientHost(message);
+  }
+
+  void OnSocketClosed() override {
+    std::string message =
+        "{ \"method\": \"Inspector.detached\", "
+        "\"params\": { \"reason\": \"Connection lost.\"} }";
+    proxy_->DispatchOnClientHost(message);
+    web_socket_.reset();
+    socket_opened_ = false;
+    proxy_->ConnectionClosed();  // Deletes |this|.
+  }
+
+ private:
+  bool socket_opened_;
+  std::vector<std::string> pending_messages_;
+  std::unique_ptr<AndroidDeviceManager::AndroidWebSocket> web_socket_;
+  content::DevToolsExternalAgentProxy* proxy_;
+  DISALLOW_COPY_AND_ASSIGN(WebSocketProxy);
+};
+
+class AgentHostDelegate : public content::DevToolsExternalAgentProxyDelegate {
  public:
   static scoped_refptr<content::DevToolsAgentHost> GetOrCreateAgentHost(
       scoped_refptr<AndroidDeviceManager::Device> device,
@@ -128,7 +173,7 @@ class AgentHostDelegate
       base::DictionaryValue* value);
   // DevToolsExternalAgentProxyDelegate overrides.
   void Attach(content::DevToolsExternalAgentProxy* proxy) override;
-  void Detach() override;
+  void Detach(content::DevToolsExternalAgentProxy* proxy) override;
   std::string GetType() override;
   std::string GetTitle() override;
   std::string GetDescription() override;
@@ -139,11 +184,8 @@ class AgentHostDelegate
   void Reload() override;
   bool Close() override;
   base::TimeTicks GetLastActivityTime() override;
-  void SendMessageToBackend(const std::string& message) override;
-
-  void OnSocketOpened() override;
-  void OnFrameRead(const std::string& message) override;
-  void OnSocketClosed() override;
+  void SendMessageToBackend(content::DevToolsExternalAgentProxy* proxy,
+                            const std::string& message) override;
 
   void SendProtocolCommand(const std::string& target_path,
                            const std::string& method,
@@ -161,11 +203,10 @@ class AgentHostDelegate
   std::string description_;
   GURL url_;
   GURL favicon_url_;
-  bool socket_opened_;
-  std::vector<std::string> pending_messages_;
-  std::unique_ptr<AndroidDeviceManager::AndroidWebSocket> web_socket_;
   content::DevToolsAgentHost* agent_host_;
-  content::DevToolsExternalAgentProxy* proxy_;
+  std::map<content::DevToolsExternalAgentProxy*,
+           std::unique_ptr<WebSocketProxy>>
+      proxies_;
   DISALLOW_COPY_AND_ASSIGN(AgentHostDelegate);
 };
 
@@ -245,33 +286,31 @@ AgentHostDelegate::AgentHostDelegate(
       remote_type_(type),
       remote_id_(value ? GetStringProperty(value, "id") : ""),
       frontend_url_(value ? GetFrontendURLFromValue(value) : ""),
-      title_(value ? base::UTF16ToUTF8(net::UnescapeForHTML(base::UTF8ToUTF16(
-          GetStringProperty(value, "title")))) : ""),
+      title_(value ? base::UTF16ToUTF8(net::UnescapeForHTML(
+                         base::UTF8ToUTF16(GetStringProperty(value, "title"))))
+                   : ""),
       description_(value ? GetStringProperty(value, "description") : ""),
       url_(GURL(value ? GetStringProperty(value, "url") : "")),
       favicon_url_(GURL(value ? GetStringProperty(value, "faviconUrl") : "")),
-      socket_opened_(false),
-      agent_host_(nullptr),
-      proxy_(nullptr) {
-}
+      agent_host_(nullptr) {}
 
 AgentHostDelegate::~AgentHostDelegate() {
 }
 
 void AgentHostDelegate::Attach(content::DevToolsExternalAgentProxy* proxy) {
-  proxy_ = proxy;
+  std::unique_ptr<WebSocketProxy> ws_proxy(new WebSocketProxy(proxy));
+  ws_proxy->WebSocketCreated(
+      device_->CreateWebSocket(browser_id_, target_path_, ws_proxy.get()));
+  proxies_[proxy] = std::move(ws_proxy);
   base::RecordAction(
       base::StartsWith(browser_id_, kWebViewSocketPrefix,
                        base::CompareCase::SENSITIVE)
           ? base::UserMetricsAction("DevTools_InspectAndroidWebView")
           : base::UserMetricsAction("DevTools_InspectAndroidPage"));
-  web_socket_.reset(
-      device_->CreateWebSocket(browser_id_, target_path_, this));
 }
 
-void AgentHostDelegate::Detach() {
-  web_socket_.reset();
-  proxy_ = nullptr;
+void AgentHostDelegate::Detach(content::DevToolsExternalAgentProxy* proxy) {
+  proxies_.erase(proxy);
 }
 
 std::string AgentHostDelegate::GetType() {
@@ -321,39 +360,14 @@ base::TimeTicks AgentHostDelegate::GetLastActivityTime() {
   return base::TimeTicks();
 }
 
-void AgentHostDelegate::SendMessageToBackend(const std::string& message) {
+void AgentHostDelegate::SendMessageToBackend(
+    content::DevToolsExternalAgentProxy* proxy,
+    const std::string& message) {
+  auto it = proxies_.find(proxy);
   // We could have detached due to physical connection being closed.
-  if (!proxy_)
+  if (it == proxies_.end())
     return;
-  if (socket_opened_)
-    web_socket_->SendFrame(message);
-  else
-    pending_messages_.push_back(message);
-}
-
-void AgentHostDelegate::OnSocketOpened() {
-  socket_opened_ = true;
-  for (std::vector<std::string>::iterator it = pending_messages_.begin();
-       it != pending_messages_.end(); ++it) {
-    SendMessageToBackend(*it);
-  }
-  pending_messages_.clear();
-}
-
-void AgentHostDelegate::OnFrameRead(const std::string& message) {
-  if (proxy_)
-      proxy_->DispatchOnClientHost(message);
-}
-
-void AgentHostDelegate::OnSocketClosed() {
-  content::DevToolsExternalAgentProxy* proxy = proxy_;
-  if (proxy) {
-    std::string message = "{ \"method\": \"Inspector.detached\", "
-        "\"params\": { \"reason\": \"Connection lost.\"} }";
-    proxy->DispatchOnClientHost(message);
-    Detach();
-    proxy->ConnectionClosed();  // May delete |this|.
- }
+  it->second->SendMessageToBackend(message);
 }
 
 void AgentHostDelegate::SendProtocolCommand(

content/browser/devtools/devtools_agent_host_impl.cc

@@ -25,6 +25,7 @@
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/devtools_external_agent_proxy_delegate.h"
 
 namespace content {
 
@@ -281,6 +282,12 @@ void DevToolsAgentHostImpl::ForceDetachAllClients(bool replaced) {
   }
 }
 
+void DevToolsAgentHostImpl::ForceDetachSession(DevToolsSession* session) {
+  DevToolsAgentHostClient* client = session->client();
+  InnerDetachClient(client);
+  client->AgentHostClosed(this, false);
+}
+
 void DevToolsAgentHostImpl::InspectElement(
     DevToolsSession* session,
     int x,

content/browser/devtools/devtools_agent_host_impl.h

@@ -61,6 +61,7 @@ class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost {
 
   void NotifyCreated();
   void ForceDetachAllClients(bool replaced);
+  void ForceDetachSession(DevToolsSession* session);
   DevToolsIOContext* GetIOContext() { return &io_context_; }
 
   base::flat_set<DevToolsSession*>& sessions() { return sessions_; }

content/browser/devtools/devtools_manager_unittest.cc

@@ -233,7 +233,9 @@ class TestExternalAgentDelegate: public DevToolsExternalAgentProxyDelegate {
     recordEvent("Attach");
   };
 
-  void Detach() override { recordEvent("Detach"); };
+  void Detach(DevToolsExternalAgentProxy* proxy) override {
+    recordEvent("Detach");
+  };
 
   std::string GetType() override { return std::string(); }
   std::string GetTitle() override { return std::string(); }
@@ -246,7 +248,8 @@ class TestExternalAgentDelegate: public DevToolsExternalAgentProxyDelegate {
   bool Close() override { return false; };
   base::TimeTicks GetLastActivityTime() override { return base::TimeTicks(); }
 
-  void SendMessageToBackend(const std::string& message) override {
+  void SendMessageToBackend(DevToolsExternalAgentProxy* proxy,
+                            const std::string& message) override {
     recordEvent(std::string("SendMessageToBackend.") + message);
   };
 

content/browser/devtools/devtools_session.h

@@ -27,6 +27,7 @@ class DevToolsSession : public protocol::FrontendChannel {
   ~DevToolsSession() override;
 
   int session_id() const { return session_id_; }
+  DevToolsAgentHostClient* client() const { return client_; }
   void AddHandler(std::unique_ptr<protocol::DevToolsDomainHandler> handler);
   void SetRenderFrameHost(RenderFrameHostImpl* host);
   void SetFallThroughForNotFound(bool value);

content/browser/devtools/forwarding_agent_host.cc

@@ -7,9 +7,35 @@
 #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, DevToolsSession* session)
+      : agent_host_(agent_host), session_(session) {
+    agent_host_->delegate_->Attach(this);
+  }
+
+  ~SessionProxy() override { agent_host_->delegate_->Detach(this); }
+
+ private:
+  void DispatchOnClientHost(const std::string& message) override {
+    session_->SendMessageToClient(message);
+  }
+
+  void ConnectionClosed() override {
+    agent_host_->ForceDetachSession(session_);
+  }
+
+  ForwardingAgentHost* agent_host_;
+  DevToolsSession* session_;
+
+  DISALLOW_COPY_AND_ASSIGN(SessionProxy);
+};
+
 ForwardingAgentHost::ForwardingAgentHost(
     const std::string& id,
     std::unique_ptr<DevToolsExternalAgentProxyDelegate> delegate)
@@ -21,28 +47,21 @@ ForwardingAgentHost::ForwardingAgentHost(
 ForwardingAgentHost::~ForwardingAgentHost() {
 }
 
-void ForwardingAgentHost::DispatchOnClientHost(const std::string& message) {
-  if (sessions().empty())
-    return;
-  (*sessions().begin())->SendMessageToClient(message);
-}
-
-void ForwardingAgentHost::ConnectionClosed() {
-  ForceDetachAllClients(false);
-}
-
 void ForwardingAgentHost::AttachSession(DevToolsSession* session) {
-  delegate_->Attach(this);
+  session_proxies_[session->session_id()].reset(
+      new SessionProxy(this, session));
 }
 
 void ForwardingAgentHost::DetachSession(int session_id) {
-  delegate_->Detach();
+  session_proxies_.erase(session_id);
 }
 
 bool ForwardingAgentHost::DispatchProtocolMessage(
     DevToolsSession* session,
     const std::string& message) {
-  delegate_->SendMessageToBackend(message);
+  auto it = session_proxies_.find(session->session_id());
+  if (it != session_proxies_.end())
+    delegate_->SendMessageToBackend(it->second.get(), message);
   return true;
 }
 

content/browser/devtools/forwarding_agent_host.h

@@ -7,27 +7,24 @@
 
 #include <memory>
 
+#include "base/containers/flat_map.h"
 #include "base/memory/ref_counted.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
-#include "content/public/browser/devtools_external_agent_proxy.h"
-#include "content/public/browser/devtools_external_agent_proxy_delegate.h"
 
 namespace content {
 
-class ForwardingAgentHost
-    : public DevToolsAgentHostImpl,
-      public DevToolsExternalAgentProxy {
+class DevToolsExternalAgentProxyDelegate;
+
+class ForwardingAgentHost : public DevToolsAgentHostImpl {
  public:
   ForwardingAgentHost(
       const std::string& id,
       std::unique_ptr<DevToolsExternalAgentProxyDelegate> delegate);
 
  private:
-  ~ForwardingAgentHost() override;
+  class SessionProxy;
 
-  // DevToolsExternalAgentProxy implementation.
-  void DispatchOnClientHost(const std::string& message) override;
-  void ConnectionClosed() override;
+  ~ForwardingAgentHost() override;
 
   // DevToolsAgentHostImpl implementation.
   void AttachSession(DevToolsSession* session) override;
@@ -48,9 +45,9 @@ class ForwardingAgentHost
   base::TimeTicks GetLastActivityTime() override;
 
   std::unique_ptr<DevToolsExternalAgentProxyDelegate> delegate_;
-  std::string type_;
-  std::string title_;
-  GURL url_;
+  base::flat_map<int, std::unique_ptr<SessionProxy>> session_proxies_;
+
+  DISALLOW_COPY_AND_ASSIGN(ForwardingAgentHost);
 };
 
 }  // namespace content

content/public/browser/devtools_external_agent_proxy_delegate.h

@@ -18,11 +18,15 @@ class DevToolsExternalAgentProxyDelegate {
  public:
   virtual ~DevToolsExternalAgentProxyDelegate() {}
 
-  // Informs the agent that a client host has attached.
+  // Informs the agent that a client has attached.
   virtual void Attach(DevToolsExternalAgentProxy* proxy) = 0;
 
-  // Informs the agent that a client host has detached.
-  virtual void Detach() = 0;
+  // Informs the agent that a client has detached.
+  virtual void Detach(DevToolsExternalAgentProxy* proxy) = 0;
+
+  // Sends a message to the agent from a client.
+  virtual void SendMessageToBackend(DevToolsExternalAgentProxy* proxy,
+                                    const std::string& message) = 0;
 
   // Returns agent host type.
   virtual std::string GetType() = 0;
@@ -53,9 +57,6 @@ class DevToolsExternalAgentProxyDelegate {
 
   // Returns the time when the host was last active.
   virtual base::TimeTicks GetLastActivityTime() = 0;
-
-  // Sends a message to the agent.
-  virtual void SendMessageToBackend(const std::string& message) = 0;
 };
 
 }  // namespace content