[DevTools] Support multiple sessions in content/ 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 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) {
+    : id_(id), last_session_id_(0), session_(nullptr) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 DevToolsAgentHostImpl::~DevToolsAgentHostImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NotifyDestroyed();
 }
 
 // static
 scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForId(
@@ skipping 17 matching lines @@
 }
 
 bool DevToolsAgentHostImpl::InnerAttachClient(DevToolsAgentHostClient* client,
                                               bool force) {
   if (session_ && !force)
     return false;
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
   if (session_)
     ForceDetach(true);
-  session_.reset(new DevToolsSession(this, client, ++last_session_id_));
-  AttachSession(session_.get());
+  DCHECK(!session_);
+  session_ = new DevToolsSession(this, client, ++last_session_id_);
+  sessions_.insert(std::unique_ptr<DevToolsSession>(session_));
+  AttachSession(session_);
   NotifyAttached();
   return true;
 }
 
 bool DevToolsAgentHostImpl::AttachClient(DevToolsAgentHostClient* client) {
   return InnerAttachClient(client, false);
 }
 
 void DevToolsAgentHostImpl::ForceAttachClient(DevToolsAgentHostClient* client) {
   InnerAttachClient(client, true);
 }
 
 bool DevToolsAgentHostImpl::DetachClient(DevToolsAgentHostClient* client) {
   if (!session_ || session_->client() != client)
     return false;
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
   InnerDetachClient();
   return true;
 }
 
 bool DevToolsAgentHostImpl::DispatchProtocolMessage(
     DevToolsAgentHostClient* client,
     const std::string& message) {
   if (!session_ || session_->client() != client)
     return false;
-  return DispatchProtocolMessage(session_.get(), message);
+  return DispatchProtocolMessage(session_, message);
 }
 
 void DevToolsAgentHostImpl::InnerDetachClient() {
   int session_id = session_->session_id();
-  session_.reset();
+  session_ = nullptr;
+  sessions_.clear();
   DetachSession(session_id);
   io_context_.DiscardAllStreams();
   NotifyDetached();
 }
 
 bool DevToolsAgentHostImpl::IsAttached() {
   return !!session_;
 }
 
 void DevToolsAgentHostImpl::InspectElement(
     DevToolsAgentHostClient* client,
     int x,
     int y) {
  if (!session_ || session_->client() != client)
    return;
- InspectElement(session_.get(), x, y);
+ InspectElement(session_, x, y);
 }
 
 std::string DevToolsAgentHostImpl::GetId() {
   return id_;
 }
 
 std::string DevToolsAgentHostImpl::GetParentId() {
   return "";
 }
 
@@ skipping 182 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