[DevTools] Rework DevToolsSession interaction with domain handlers.

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 88 matching lines @@
           ->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),
-      client_(NULL) {
+      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::InnerAttach(DevToolsAgentHostClient* client,
-                                        bool force) {
-  if (client_ && !force)
+bool DevToolsAgentHostImpl::InnerAttachClient(DevToolsAgentHostClient* client,
+                                              bool force) {
+  if (session_ && !force)
     return false;
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
-  if (client_) {
-    client_->AgentHostClosed(this, true);
-    InnerDetach();
+  if (session_) {
+    session_->client()->AgentHostClosed(this, true);
+    InnerDetachClient();
   }
-  client_ = client;
-  session_.reset(new DevToolsSession(this, ++last_session_id_));
-  Attach();
+  session_.reset(new DevToolsSession(this, client, ++last_session_id_));
+  AttachSession(session_.get());
   NotifyAttached();
   return true;
 }
 
 bool DevToolsAgentHostImpl::AttachClient(DevToolsAgentHostClient* client) {
-  return InnerAttach(client, false);
+  return InnerAttachClient(client, false);
 }
 
 void DevToolsAgentHostImpl::ForceAttachClient(DevToolsAgentHostClient* client) {
-  InnerAttach(client, true);
+  InnerAttachClient(client, true);
 }
 
 bool DevToolsAgentHostImpl::DetachClient(DevToolsAgentHostClient* client) {
-  if (!client_ || client_ != client)
+  if (!session_ || session_->client() != client)
     return false;
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
-  client_ = NULL;
-  InnerDetach();
+  InnerDetachClient();
   return true;
 }
 
 bool DevToolsAgentHostImpl::DispatchProtocolMessage(
     DevToolsAgentHostClient* client,
     const std::string& message) {
-  if (!client_ || client_ != client)
+  if (!session_ || session_->client() != client)
     return false;
-  return DispatchProtocolMessage(message);
+  return DispatchProtocolMessage(session_.get(), message);
 }
 
-void DevToolsAgentHostImpl::InnerDetach() {
-  session_->ResetDispatcher();
-  Detach();
+void DevToolsAgentHostImpl::InnerDetachClient() {
+  int session_id = session_->session_id();
+  session_.reset();
+  DetachSession(session_id);
   io_context_.DiscardAllStreams();
-  session_.reset();
   NotifyDetached();
 }
 
 bool DevToolsAgentHostImpl::IsAttached() {
-  return !!client_;
+  return !!session_;
 }
 
 void DevToolsAgentHostImpl::InspectElement(
     DevToolsAgentHostClient* client,
     int x,
     int y) {
- if (!client_ || client_ != client)
+ if (!session_ || session_->client() != client)
    return;
- InspectElement(x, y);
+ InspectElement(session_.get(), x, y);
 }
 
 std::string DevToolsAgentHostImpl::GetId() {
   return id_;
 }
 
 std::string DevToolsAgentHostImpl::GetParentId() {
   return "";
 }
 
@@ skipping 30 matching lines @@
 bool DevToolsAgentHostImpl::Inspect() {
   DevToolsManager* manager = DevToolsManager::GetInstance();
   if (manager->delegate()) {
     manager->delegate()->Inspect(this);
     return true;
   }
   return false;
 }
 
 void DevToolsAgentHostImpl::HostClosed() {
-  if (!client_)
+  if (!session_)
     return;
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
   // Clear |client_| before notifying it.
-  DevToolsAgentHostClient* client = client_;
-  client_ = NULL;
+  DevToolsAgentHostClient* client = session_->client();
+  InnerDetachClient();
   client->AgentHostClosed(this, false);
-  InnerDetach();
 }
 
-void DevToolsAgentHostImpl::InspectElement(int x, int y) {
+void DevToolsAgentHostImpl::InspectElement(
+    DevToolsSession* session,
+    int x,
+    int y) {
 }
 
 void DevToolsAgentHostImpl::SendMessageToClient(int session_id,
                                                 const std::string& message) {
-  if (!client_)
-    return;
   // Filter any messages from previous sessions.
   if (!session_ || session_id != session_->session_id())
     return;
-  client_->DispatchProtocolMessage(this, message);
+  session_->client()->DispatchProtocolMessage(this, message);
 }
 
 // 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;
-    if (agent_host->client_) {
+    if (agent_host->session_) {

[caseq, 2016/12/21 23:17:27]

nit: parametrize HostClosed() with bool and call it here.

[dgozman, 2016/12/22 06:26:13]

Done.

       scoped_refptr<DevToolsAgentHostImpl> protect(agent_host);
       // Clear |client_| before notifying it.
-      DevToolsAgentHostClient* client = agent_host->client_;
-      agent_host->client_ = NULL;
+      DevToolsAgentHostClient* client = agent_host->session_->client();
+      agent_host->InnerDetachClient();
       client->AgentHostClosed(agent_host, true);
-      agent_host->InnerDetach();
     }
   }
 }
 
 // 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 99 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