[DevTools] Introduce DevToolsSession.

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"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/observer_list.h"
 #include "content/browser/devtools/devtools_manager.h"
+#include "content/browser/devtools/devtools_session.h"
 #include "content/browser/devtools/forwarding_agent_host.h"
 #include "content/browser/devtools/protocol/devtools_protocol_dispatcher.h"
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/devtools/shared_worker_devtools_agent_host.h"
 #include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/loader/netlog_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
@@ skipping 70 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),
-      session_id_(0),
+      last_session_id_(0),
       client_(NULL) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 DevToolsAgentHostImpl::~DevToolsAgentHostImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NotifyDestroyed();
 }
 
 // static
@@ skipping 16 matching lines @@
     return result;
   return new ForwardingAgentHost(id, std::move(delegate));
 }
 
 bool DevToolsAgentHostImpl::InnerAttach(DevToolsAgentHostClient* client,
                                         bool force) {
   if (client_ && !force)
     return false;
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
-  ++session_id_;
   if (client_) {
     client_->AgentHostClosed(this, true);
     InnerDetach();
   }
   client_ = client;
+  session_.reset(new DevToolsSession(this, ++last_session_id_));
   Attach();
   NotifyAttached();
   return true;
 }
 
 bool DevToolsAgentHostImpl::AttachClient(DevToolsAgentHostClient* client) {
   return InnerAttach(client, false);
 }
 
 void DevToolsAgentHostImpl::ForceAttachClient(DevToolsAgentHostClient* client) {
@@ skipping 14 matching lines @@
     DevToolsAgentHostClient* client,
     const std::string& message) {
   if (!client_ || client_ != client)
     return false;
   return DispatchProtocolMessage(message);
 }
 
 void DevToolsAgentHostImpl::InnerDetach() {
   Detach();
   io_context_.DiscardAllStreams();
+  session_.reset();
   NotifyDetached();
 }
 
 bool DevToolsAgentHostImpl::IsAttached() {
   return !!client_;
 }
 
 void DevToolsAgentHostImpl::InspectElement(
     DevToolsAgentHostClient* client,
     int x,
@@ skipping 50 matching lines @@
   return false;
 }
 
 void DevToolsAgentHostImpl::SendProtocolResponse(int session_id,
                                                  const std::string& message) {
   SendMessageToClient(session_id, message);
 }
 
 void DevToolsAgentHostImpl::SendProtocolNotification(
     const std::string& message) {
-  SendMessageToClient(session_id_, message);
+  SendMessageToClient(session_ ? session_->session_id() : 0, message);
 }
 
 void DevToolsAgentHostImpl::HostClosed() {
   if (!client_)
     return;
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
   // Clear |client_| before notifying it.
   DevToolsAgentHostClient* client = client_;
   client_ = NULL;
   client->AgentHostClosed(this, false);
   NotifyDetached();
 }
 
 void DevToolsAgentHostImpl::InspectElement(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_id != session_id_)
+  if (!session_ || session_id != session_->session_id())
     return;
   client_->DispatchProtocolMessage(this, message);
 }
 
 // static
 void DevToolsAgentHost::DetachAllClients() {
   if (g_instances == NULL)
     return;
 
   // Make a copy, since detaching may lead to agent destruction, which
@@ skipping 120 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