[DevTools] Make DevToolsSession own it's DevToolsMessageChunkProcessor

content/browser/devtools/render_frame_devtools_agent_host.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/render_frame_devtools_agent_host.h"
 
 #include <tuple>
 #include <utility>
 
 #include "base/guid.h"
@@ skipping 177 matching lines @@
   attached_ = false;
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::DispatchProtocolMessage(
     int session_id,
     int call_id,
     const std::string& method,
     const std::string& message) {
   host_->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
       host_->GetRoutingID(), session_id, call_id, method, message));
-  sent_messages_[call_id] = { session_id, method, message };
+  sent_messages_[call_id] = {session_id, call_id, method, message};
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::InspectElement(
     int session_id, int x, int y) {
   DCHECK(attached_);
   host_->Send(new DevToolsAgentMsg_InspectElement(
       host_->GetRoutingID(), session_id, x, y));
 }
 
 bool
@@ skipping 185 matching lines @@
     DevToolsAgentHost::GetOrCreateFor(web_contents);
   }
 }
 
 RenderFrameDevToolsAgentHost::RenderFrameDevToolsAgentHost(
     FrameTreeNode* frame_tree_node)
     : DevToolsAgentHostImpl(base::GenerateGUID()),
       frame_trace_recorder_(nullptr),
       handlers_frame_host_(nullptr),
       current_frame_crashed_(false),
-      chunk_processor_(
-          base::Bind(&RenderFrameDevToolsAgentHost::SendMessageFromProcessor,
-                     base::Unretained(this))),
       frame_tree_node_(frame_tree_node) {
   if (IsBrowserSideNavigationEnabled()) {
     frame_host_ = frame_tree_node->current_frame_host();
     render_frame_alive_ = frame_host_ && frame_host_->IsRenderFrameLive();
   } else {
     if (frame_tree_node->current_frame_host()) {
       SetPending(frame_tree_node->current_frame_host());
       CommitPending();
     }
   }
@@ skipping 121 matching lines @@
   int call_id = 0;
   std::string method;
   int session_id = session->session_id();
   if (session->Dispatch(message, &call_id, &method) !=
       protocol::Response::kFallThrough) {
     return true;
   }
 
   if (IsBrowserSideNavigationEnabled()) {
     if (!navigation_handles_.empty()) {
-      suspended_messages_[call_id] = {session_id, method, message};
+      suspended_messages_.push_back({session_id, call_id, method, message});
       return true;
     }
     if (frame_host_) {
       frame_host_->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
           frame_host_->GetRoutingID(), session_id, call_id, method, message));
     }
-    waiting_for_response_messages_[call_id] = {session_id, method, message};
+    session->waiting_messages()[call_id] = {method, message};
   } else {
     if (current_)
       current_->DispatchProtocolMessage(session_id, call_id, method, message);
     if (pending_)
       pending_->DispatchProtocolMessage(session_id, call_id, method, message);
   }
   return true;
 }
 
 void RenderFrameDevToolsAgentHost::InspectElement(
@@ skipping 23 matching lines @@
 #endif
   if (IsBrowserSideNavigationEnabled())
     GrantPolicy(frame_host_);
 }
 
 void RenderFrameDevToolsAgentHost::OnClientDetached() {
 #if defined(OS_ANDROID)
   GetWakeLock()->CancelWakeLock();
 #endif
   frame_trace_recorder_.reset();
-  waiting_for_response_messages_.clear();
   suspended_messages_.clear();
-  chunk_processor_.Reset();
   if (IsBrowserSideNavigationEnabled())
     RevokePolicy(frame_host_);
 }
 
 RenderFrameDevToolsAgentHost::~RenderFrameDevToolsAgentHost() {
   Instances::iterator it = std::find(g_instances.Get().begin(),
                                      g_instances.Get().end(),
                                      this);
   if (it != g_instances.Get().end())
     g_instances.Get().erase(it);
@@ skipping 40 matching lines @@
   if (handle->frame_tree_node() != frame_tree_node_)
     return;
   navigation_handles_.erase(handle);
 
   // UpdateFrameHost may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
   if (handle->HasCommitted() && !handle->IsErrorPage())
     UpdateFrameHost(handle->GetRenderFrameHost());
   DCHECK(CheckConsistency());
   if (navigation_handles_.empty()) {
-    if (session() && frame_host_) {
-      for (const auto& pair : suspended_messages_) {
-        const Message& message = pair.second;
-        frame_host_->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
-            frame_host_->GetRoutingID(), message.session_id, pair.first,
-            message.method, message.message));
+    if (session()) {
+      for (const Message& message : suspended_messages_) {
+        if (frame_host_) {
+          frame_host_->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
+              frame_host_->GetRoutingID(), message.session_id, message.call_id,
+              message.method, message.message));
+        }
+        session()->waiting_messages()[message.call_id] = {message.method,
+                                                          message.message};
       }
     }
-    waiting_for_response_messages_.insert(suspended_messages_.begin(),
-                                          suspended_messages_.end());
     suspended_messages_.clear();
   }
   if (handle->HasCommitted()) {
     for (auto* target : protocol::TargetHandler::ForAgentHost(this))
       target->UpdateServiceWorkers();
   }
 }
 
 void RenderFrameDevToolsAgentHost::UpdateFrameHost(
     RenderFrameHostImpl* frame_host) {
@@ skipping 21 matching lines @@
     session()->SetRenderFrameHost(frame_host);
     MaybeReattachToRenderFrame();
   }
 }
 
 void RenderFrameDevToolsAgentHost::MaybeReattachToRenderFrame() {
   DCHECK(IsBrowserSideNavigationEnabled());
   if (!session() || !frame_host_)
     return;
   int session_id = session()->session_id();
-  frame_host_->Send(new DevToolsAgentMsg_Reattach(
-      frame_host_->GetRoutingID(), GetId(), session_id,
-      chunk_processor_.state_cookie()));
-  for (const auto& pair : waiting_for_response_messages_) {
-    const Message& message = pair.second;
+  frame_host_->Send(new DevToolsAgentMsg_Reattach(frame_host_->GetRoutingID(),
+                                                  GetId(), session_id,
+                                                  session()->state_cookie()));
+  for (const auto& pair : session()->waiting_messages()) {
+    int call_id = pair.first;
+    const DevToolsSession::Message& message = pair.second;
     frame_host_->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
-        frame_host_->GetRoutingID(), message.session_id, pair.first,
-        message.method, message.message));
+        frame_host_->GetRoutingID(), session_id, call_id, message.method,
+        message.message));
   }
 }
 
-void RenderFrameDevToolsAgentHost::SendMessageFromProcessor(
-    int session_id,
-    const std::string& message) {
-  int id = chunk_processor_.last_call_id();
-  waiting_for_response_messages_.erase(id);
-  SendMessageToClient(session_id, message);
-  // |this| may be deleted at this point.
-}
-
 void RenderFrameDevToolsAgentHost::GrantPolicy(RenderFrameHostImpl* host) {
   if (!host)
     return;
   ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadRawCookies(
       host->GetProcess()->GetID());
 }
 
 void RenderFrameDevToolsAgentHost::RevokePolicy(RenderFrameHostImpl* host) {
   if (!host)
     return;
@@ skipping 517 matching lines @@
     }
   }
 }
 
 void RenderFrameDevToolsAgentHost::OnDispatchOnInspectorFrontend(
     RenderFrameHost* sender,
     const DevToolsMessageChunk& message) {
   bool success = true;
   if (IsBrowserSideNavigationEnabled()) {
     if (sender == frame_host_)
-      success = chunk_processor_.ProcessChunkedMessageFromAgent(message);
+      success = session()->ReceiveMessageChunk(message);
   } else {
     if (current_ && current_->host() == sender)
       success = current_->ProcessChunkedMessageFromAgent(message);
     else if (pending_ && pending_->host() == sender)
       success = pending_->ProcessChunkedMessageFromAgent(message);
   }
   if (!success) {
     bad_message::ReceivedBadMessage(
         sender->GetProcess(),
         bad_message::RFH_INCONSISTENT_DEVTOOLS_MESSAGE);
@@ skipping 16 matching lines @@
 
   sender->Send(new DevToolsAgentMsg_RequestNewWindow_ACK(
       sender->GetRoutingID(), success));
 }
 
 bool RenderFrameDevToolsAgentHost::IsChildFrame() {
   return frame_tree_node_ && frame_tree_node_->parent();
 }
 
 }  // namespace content