[DevTools] Support multiple DevToolsMessageChunkProcessor instances

content/browser/devtools/worker_devtools_agent_host.cc

 // Copyright 2014 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/worker_devtools_agent_host.h"
 
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "content/browser/devtools/devtools_session.h"
 #include "content/browser/devtools/protocol/inspector_handler.h"
@@ skipping 12 matching lines @@
 
 void WorkerDevToolsAgentHost::AttachSession(DevToolsSession* session) {
   if (state_ != WORKER_INSPECTED) {
     state_ = WORKER_INSPECTED;
     AttachToWorker();
   }
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first)) {
     host->Send(new DevToolsAgentMsg_Attach(
         worker_id_.second, GetId(), session->session_id()));
   }
+  chunk_processors_[session->session_id()].reset(
+      new DevToolsMessageChunkProcessor(
+          base::Bind(&WorkerDevToolsAgentHost::SendChunkedMessage,
+                     base::Unretained(this))));
   session->SetFallThroughForNotFound(true);
   session->AddHandler(base::WrapUnique(new protocol::InspectorHandler()));
   session->AddHandler(base::WrapUnique(new protocol::NetworkHandler()));
   session->AddHandler(base::WrapUnique(new protocol::SchemaHandler()));
   OnAttachedStateChanged(true);
 }
 
 void WorkerDevToolsAgentHost::DetachSession(int session_id) {
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first))
     host->Send(new DevToolsAgentMsg_Detach(worker_id_.second, session_id));
+  chunk_processors_.erase(session_id);
   OnAttachedStateChanged(false);
   if (state_ == WORKER_INSPECTED) {
     state_ = WORKER_UNINSPECTED;
     DetachFromWorker();
   } else if (state_ == WORKER_PAUSED_FOR_REATTACH) {
     state_ = WORKER_UNINSPECTED;
   }
 }
 
 bool WorkerDevToolsAgentHost::DispatchProtocolMessage(
@@ skipping 42 matching lines @@
   return state_ == WORKER_INSPECTED || state_ == WORKER_UNINSPECTED ||
          state_ == WORKER_READY_FOR_DEBUG_ON_START;
 }
 
 void WorkerDevToolsAgentHost::WorkerReadyForInspection() {
   if (state_ == WORKER_PAUSED_FOR_REATTACH) {
     DCHECK(IsAttached());
     state_ = WORKER_INSPECTED;
     AttachToWorker();
     if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first)) {
+      std::string state_cookie;
+      auto it = chunk_processors_.find(session()->session_id());
+      if (it != chunk_processors_.end())
+        state_cookie = it->second->state_cookie();
       host->Send(new DevToolsAgentMsg_Reattach(
-          worker_id_.second, GetId(), session()->session_id(),
-          chunk_processor_.state_cookie()));
+          worker_id_.second, GetId(), session()->session_id(), state_cookie));
     }
     OnAttachedStateChanged(true);
   } else if (state_ == WORKER_PAUSED_FOR_DEBUG_ON_START) {
     state_ = WORKER_READY_FOR_DEBUG_ON_START;
   }
 }
 
 void WorkerDevToolsAgentHost::WorkerRestarted(WorkerId worker_id) {
   DCHECK_EQ(WORKER_TERMINATED, state_);
   state_ = IsAttached() ? WORKER_PAUSED_FOR_REATTACH : WORKER_UNINSPECTED;
@@ skipping 12 matching lines @@
   state_ = WORKER_TERMINATED;
   Release();  // Balanced in WorkerCreated().
 }
 
 bool WorkerDevToolsAgentHost::IsTerminated() {
   return state_ == WORKER_TERMINATED;
 }
 
 WorkerDevToolsAgentHost::WorkerDevToolsAgentHost(WorkerId worker_id)
     : DevToolsAgentHostImpl(base::GenerateGUID()),
-      chunk_processor_(base::Bind(&WorkerDevToolsAgentHost::SendMessageToClient,
-                                  base::Unretained(this))),
       state_(WORKER_UNINSPECTED),
       worker_id_(worker_id) {
   WorkerCreated();
 }
 
 WorkerDevToolsAgentHost::~WorkerDevToolsAgentHost() {
   DCHECK_EQ(WORKER_TERMINATED, state_);
 }
 
 void WorkerDevToolsAgentHost::OnAttachedStateChanged(bool attached) {
 }
 
 void WorkerDevToolsAgentHost::AttachToWorker() {
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first))
     host->AddRoute(worker_id_.second, this);
 }
 
 void WorkerDevToolsAgentHost::DetachFromWorker() {
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first))
     host->RemoveRoute(worker_id_.second);
 }
 
 void WorkerDevToolsAgentHost::WorkerCreated() {
   AddRef();  // Balanced in WorkerDestroyed()
 }
 
 void WorkerDevToolsAgentHost::OnDispatchOnInspectorFrontend(
     const DevToolsMessageChunk& message) {
-  if (!IsAttached())
-    return;
+  auto it = chunk_processors_.find(message.session_id);
+  if (it != chunk_processors_.end())
+    it->second->ProcessChunkedMessageFromAgent(message);
+}
 
-  chunk_processor_.ProcessChunkedMessageFromAgent(message);
+void WorkerDevToolsAgentHost::SendChunkedMessage(int session_id,
+                                                 const std::string& message) {
+  if (session() && session()->session_id() == session_id)
+    session()->SendMessageToClient(message);
 }
 
 }  // namespace content