[DevTools] Support multiple clients in DevToolsAgentHost

content/browser/devtools/devtools_agent_host_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/devtools/devtools_agent_host_impl.h"
 
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 100 matching lines @@
       SharedWorkerDevToolsManager::GetInstance()
           ->GetDevToolsAgentHostForWorker(worker_process_id,
                                           worker_route_id)) {
     return host;
   }
   return ServiceWorkerDevToolsManager::GetInstance()
       ->GetDevToolsAgentHostForWorker(worker_process_id, worker_route_id);
 }
 
 DevToolsAgentHostImpl::DevToolsAgentHostImpl(const std::string& id)
-    : id_(id), last_session_id_(0), session_(nullptr) {
+    : id_(id), last_session_id_(0) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 DevToolsAgentHostImpl::~DevToolsAgentHostImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NotifyDestroyed();
 }
 
 // static
 scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForId(
     const std::string& id) {
   if (g_instances == NULL)
     return NULL;
   Instances::iterator it = g_instances.Get().find(id);
   if (it == g_instances.Get().end())
     return NULL;
   return it->second;
 }
 
 // static
 scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::Forward(
     const std::string& id,
     std::unique_ptr<DevToolsExternalAgentProxyDelegate> delegate) {
   scoped_refptr<DevToolsAgentHost> result = DevToolsAgentHost::GetForId(id);
   if (result)
     return result;
   return new ForwardingAgentHost(id, std::move(delegate));
 }
 
-bool DevToolsAgentHostImpl::InnerAttachClient(DevToolsAgentHostClient* client,
-                                              bool force) {
-  if (session_ && !force)
+void DevToolsAgentHostImpl::InnerAttachClient(DevToolsAgentHostClient* client) {
+  scoped_refptr<DevToolsAgentHostImpl> protect(this);
+  DevToolsSession* session =
+      new DevToolsSession(this, client, ++last_session_id_);
+  session_by_client_[client].reset(session);
+  session_by_id_[session->session_id()] = session;
+  AttachSession(session);
+  if (session_by_client_.size() == 1)
+    NotifyAttached();
+}
+
+bool DevToolsAgentHostImpl::AttachClient(DevToolsAgentHostClient* client) {
+  if (!session_by_client_.empty())
     return false;
-
-  scoped_refptr<DevToolsAgentHostImpl> protect(this);
-  if (session_)
-    ForceDetach(true);
-  DCHECK(!session_);
-  session_ = new DevToolsSession(this, client, ++last_session_id_);
-  sessions_.insert(std::unique_ptr<DevToolsSession>(session_));
-  AttachSession(session_);
-  NotifyAttached();
+  InnerAttachClient(client);
   return true;
 }
 
-bool DevToolsAgentHostImpl::AttachClient(DevToolsAgentHostClient* client) {
-  return InnerAttachClient(client, false);
+void DevToolsAgentHostImpl::ForceAttachClient(DevToolsAgentHostClient* client) {
+  scoped_refptr<DevToolsAgentHostImpl> protect(this);
+  if (!session_by_client_.empty())
+    ForceDetachAllClients(true);
+  DCHECK(session_by_client_.empty());
+  InnerAttachClient(client);
 }
 
-void DevToolsAgentHostImpl::ForceAttachClient(DevToolsAgentHostClient* client) {
-  InnerAttachClient(client, true);
+bool DevToolsAgentHostImpl::AttachMultiClient(DevToolsAgentHostClient* client) {
+  InnerAttachClient(client);
+  return true;
 }
 
 bool DevToolsAgentHostImpl::DetachClient(DevToolsAgentHostClient* client) {
-  if (!session_ || session_->client() != client)
+  if (session_by_client_.find(client) == session_by_client_.end())
     return false;
-
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
-  InnerDetachClient();
+  InnerDetachClient(client);
   return true;
 }
 
 bool DevToolsAgentHostImpl::DispatchProtocolMessage(
     DevToolsAgentHostClient* client,
     const std::string& message) {
-  if (!session_ || session_->client() != client)
+  auto it = session_by_client_.find(client);
+  if (it == session_by_client_.end())
     return false;
-  return DispatchProtocolMessage(session_, message);
+  return DispatchProtocolMessage(it->second.get(), message);
 }
 
-void DevToolsAgentHostImpl::InnerDetachClient() {
-  int session_id = session_->session_id();
-  session_ = nullptr;
-  sessions_.clear();
+void DevToolsAgentHostImpl::InnerDetachClient(DevToolsAgentHostClient* client) {
+  auto it = session_by_client_.find(client);
+  DCHECK(it != session_by_client_.end());
+  int session_id = it->second->session_id();
+  session_by_client_.erase(it);
+  session_by_id_.erase(session_id);
   DetachSession(session_id);
-  io_context_.DiscardAllStreams();
-  NotifyDetached();
+  if (session_by_client_.empty()) {
+    io_context_.DiscardAllStreams();
+    NotifyDetached();
+  }
 }
 
 bool DevToolsAgentHostImpl::IsAttached() {
-  return !!session_;
+  return !session_by_client_.empty();
 }
 
 void DevToolsAgentHostImpl::InspectElement(
     DevToolsAgentHostClient* client,
     int x,
     int y) {
- if (!session_ || session_->client() != client)
-   return;
- InspectElement(session_, x, y);
+  auto it = session_by_client_.find(client);
+  if (it == session_by_client_.end())
+    return;
+  InspectElement(it->second.get(), x, y);
 }
 
 std::string DevToolsAgentHostImpl::GetId() {
   return id_;
 }
 
 std::string DevToolsAgentHostImpl::GetParentId() {
   return "";
 }
 
@@ skipping 29 matching lines @@
 
 bool DevToolsAgentHostImpl::Inspect() {
   DevToolsManager* manager = DevToolsManager::GetInstance();
   if (manager->delegate()) {
     manager->delegate()->Inspect(this);
     return true;
   }
   return false;
 }
 
-void DevToolsAgentHostImpl::ForceDetach(bool replaced) {
-  if (!session_)
-    return;
+void DevToolsAgentHostImpl::ForceDetachAllClients(bool replaced) {
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
-  // Clear |client_| before notifying it.
-  DevToolsAgentHostClient* client = session_->client();
-  InnerDetachClient();
-  client->AgentHostClosed(this, replaced);
+  while (!session_by_client_.empty()) {
+    DevToolsAgentHostClient* client = session_by_client_.begin()->first;
+    InnerDetachClient(client);
+    client->AgentHostClosed(this, replaced);
+  }
 }
 
 void DevToolsAgentHostImpl::InspectElement(
     DevToolsSession* session,
     int x,
     int y) {
 }
 
 // static
 void DevToolsAgentHost::DetachAllClients() {
   if (g_instances == NULL)
     return;
 
   // Make a copy, since detaching may lead to agent destruction, which
   // removes it from the instances.
   Instances copy = g_instances.Get();
   for (Instances::iterator it(copy.begin()); it != copy.end(); ++it) {
     DevToolsAgentHostImpl* agent_host = it->second;
-    agent_host->ForceDetach(true);
+    agent_host->ForceDetachAllClients(true);
   }
 }
 
 // static
 void DevToolsAgentHost::AddObserver(DevToolsAgentHostObserver* observer) {
   if (observer->ShouldForceDevToolsAgentHostCreation()) {
     if (!DevToolsAgentHostImpl::s_force_creation_count_) {
       // Force all agent hosts when first observer is added.
       DevToolsAgentHost::GetOrCreateAll();
     }
@@ skipping 98 matching lines @@
     if (message_buffer_.size() != message_buffer_size_)
       return false;
     callback_.Run(chunk.session_id, message_buffer_);
     message_buffer_ = std::string();
     message_buffer_size_ = 0;
   }
   return true;
 }
 
 }  // namespace content