[DevTools] Support multiple sessions in content/ domain handlers

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 387 matching lines @@
     NavigationHandle* navigation_handle) {
   FrameTreeNode* frame_tree_node =
       static_cast<NavigationHandleImpl*>(navigation_handle)->frame_tree_node();
   while (frame_tree_node && frame_tree_node->parent()) {
     frame_tree_node = frame_tree_node->parent();
   }
   RenderFrameDevToolsAgentHost* agent_host = FindAgentHost(frame_tree_node);
   // Note Page.setControlNavigations is intended to control navigations in the
   // main frame and all child frames and |page_handler_| only exists for the
   // main frame.
-  if (!agent_host || !agent_host->session())
+  if (!agent_host)
     return nullptr;
-  protocol::PageHandler* page_handler =
-      protocol::PageHandler::FromSession(agent_host->session());
-  if (!page_handler)
-    return nullptr;
-  return page_handler->CreateThrottleForNavigation(navigation_handle);
+  for (auto* page_handler : protocol::PageHandler::ForAgentHost(agent_host)) {
+    std::unique_ptr<NavigationThrottle> throttle =
+        page_handler->CreateThrottleForNavigation(navigation_handle);
+    if (throttle)
+      return throttle;
+  }
+  return nullptr;
 }
 
 // static
 bool RenderFrameDevToolsAgentHost::IsNetworkHandlerEnabled(
     FrameTreeNode* frame_tree_node) {
   RenderFrameDevToolsAgentHost* agent_host = GetAgentHostFor(frame_tree_node);
-  if (!agent_host || !agent_host->session())
+  if (!agent_host)
     return false;
-  return protocol::NetworkHandler::FromSession(agent_host->session())
-      ->enabled();
+  for (auto* network : protocol::NetworkHandler::ForAgentHost(agent_host)) {
+    if (network->enabled())
+      return true;
+  }
+  return false;
 }
 
 // static
 std::string RenderFrameDevToolsAgentHost::UserAgentOverride(
     FrameTreeNode* frame_tree_node) {
   RenderFrameDevToolsAgentHost* agent_host = GetAgentHostFor(frame_tree_node);
-  if (!agent_host || !agent_host->session())
+  if (!agent_host)
     return std::string();
-  return protocol::NetworkHandler::FromSession(agent_host->session())
-      ->UserAgentOverride();
+  for (auto* network : protocol::NetworkHandler::ForAgentHost(agent_host)) {
+    std::string override = network->UserAgentOverride();
+    if (!override.empty())
+      return override;
+  }
+  return std::string();
 }
 
 // static
 void RenderFrameDevToolsAgentHost::WebContentsCreated(
     WebContents* web_contents) {
   if (ShouldForceCreation()) {
     // Force agent host.
     DevToolsAgentHost::GetOrCreateFor(web_contents);
   }
 }
@@ skipping 210 matching lines @@
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
 
   if (!IsBrowserSideNavigationEnabled()) {
     if (navigation_handle->HasCommitted() &&
         !navigation_handle->IsErrorPage()) {
       if (pending_ &&
           pending_->host() == navigation_handle->GetRenderFrameHost()) {
         CommitPending();
       }
-      if (session())
-        protocol::TargetHandler::FromSession(session())->UpdateServiceWorkers();
+      for (auto* target : protocol::TargetHandler::ForAgentHost(this))
+        target->UpdateServiceWorkers();
     } else if (pending_ && pending_->host()->GetFrameTreeNodeId() ==
                                navigation_handle->GetFrameTreeNodeId()) {
       DiscardPending();
     }
     DCHECK(CheckConsistency());
     return;
   }
 
   // If the navigation is not tracked, return;
   if (navigating_handles_.count(navigation_handle) == 0)
@@ skipping 12 matching lines @@
     } else {
       DiscardPending();
     }
     pending_handle_ = nullptr;
   } else if (navigating_handles_.empty()) {
     current_->Resume();
   }
   DispatchBufferedProtocolMessagesIfNecessary();
 
   DCHECK(CheckConsistency());
-  if (session() && navigation_handle->HasCommitted())
-    protocol::TargetHandler::FromSession(session())->UpdateServiceWorkers();
+  if (navigation_handle->HasCommitted()) {
+    for (auto* target : protocol::TargetHandler::ForAgentHost(this))
+      target->UpdateServiceWorkers();
+  }
 }
 
 void RenderFrameDevToolsAgentHost::AboutToNavigateRenderFrame(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
 
   if (IsBrowserSideNavigationEnabled())
     return;
@@ skipping 24 matching lines @@
   navigating_handles_.insert(navigation_handle);
   current_->Suspend();
   DCHECK(CheckConsistency());
 }
 
 void RenderFrameDevToolsAgentHost::OnFailedNavigation(
     const CommonNavigationParams& common_params,
     const BeginNavigationParams& begin_params,
     net::Error error_code) {
   DCHECK(IsBrowserSideNavigationEnabled());
-  if (!session())
-    return;
-
-  protocol::NetworkHandler* handler =
-      protocol::NetworkHandler::FromSession(session());
-  if (!handler)
-    return;
-
-  handler->NavigationFailed(common_params, begin_params, error_code);
+  for (auto* network : protocol::NetworkHandler::ForAgentHost(this))
+    network->NavigationFailed(common_params, begin_params, error_code);
 }
 
 void RenderFrameDevToolsAgentHost::RenderFrameHostChanged(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
 
-  if (session())
-    protocol::TargetHandler::FromSession(session())->UpdateFrames();
+  for (auto* target : protocol::TargetHandler::ForAgentHost(this))
+    target->UpdateFrames();
 
   if (IsBrowserSideNavigationEnabled() && !current_frame_crashed_)
     return;
 
   DCHECK(!pending_ || pending_->host() != old_host);
   if (!current_ || current_->host() != old_host) {
     DCHECK(CheckConsistency());
     return;
   }
 
@@ skipping 71 matching lines @@
     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
 #if defined(OS_CHROMEOS)
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM:
 #endif
     case base::TERMINATION_STATUS_PROCESS_CRASHED:
 #if defined(OS_ANDROID)
     case base::TERMINATION_STATUS_OOM_PROTECTED:
 #endif
     case base::TERMINATION_STATUS_LAUNCH_FAILED:
-      if (session())
-        protocol::InspectorHandler::FromSession(session())->TargetCrashed();
+      for (auto* inspector : protocol::InspectorHandler::ForAgentHost(this))
+        inspector->TargetCrashed();
       current_frame_crashed_ = true;
       break;
     default:
-      if (session()) {
-        protocol::InspectorHandler::FromSession(session())
-            ->TargetDetached("Render process gone.");
-      }
+      for (auto* inspector : protocol::InspectorHandler::ForAgentHost(this))
+        inspector->TargetDetached("Render process gone.");
       break;
   }
   DCHECK(CheckConsistency());
 }
 
 bool RenderFrameDevToolsAgentHost::OnMessageReceived(
     const IPC::Message& message,
     RenderFrameHost* render_frame_host) {
   bool is_current = current_ && current_->host() == render_frame_host;
   bool is_pending = pending_ && pending_->host() == render_frame_host;
   if (!is_current && !is_pending)
     return false;
   if (!IsAttached())
     return false;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(RenderFrameDevToolsAgentHost, message,
                                    render_frame_host)
     IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
                         OnDispatchOnInspectorFrontend)
     IPC_MESSAGE_HANDLER(DevToolsAgentHostMsg_RequestNewWindow,
                         OnRequestNewWindow)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void RenderFrameDevToolsAgentHost::DidAttachInterstitialPage() {
-  protocol::PageHandler* page_handler =
-      session() ? protocol::PageHandler::FromSession(session()) : nullptr;
-  if (page_handler)
-    page_handler->DidAttachInterstitialPage();
+  for (auto* page : protocol::PageHandler::ForAgentHost(this))
+    page->DidAttachInterstitialPage();
 
   // TODO(dgozman): this may break for cross-process subframes.
   if (!pending_) {
     DCHECK(CheckConsistency());
     return;
   }
   // Pending set in AboutToNavigateRenderFrame turned out to be interstitial.
   // Connect back to the real one.
   DiscardPending();
   pending_handle_ = nullptr;
   DCHECK(CheckConsistency());
 }
 
 void RenderFrameDevToolsAgentHost::DidDetachInterstitialPage() {
-  protocol::PageHandler* page_handler =
-      session() ? protocol::PageHandler::FromSession(session()) : nullptr;
-  if (page_handler)
-    page_handler->DidDetachInterstitialPage();
+  for (auto* page : protocol::PageHandler::ForAgentHost(this))
+    page->DidDetachInterstitialPage();
 }
 
 void RenderFrameDevToolsAgentHost::WasShown() {
   CreatePowerSaveBlocker();
 }
 
 void RenderFrameDevToolsAgentHost::WasHidden() {
 #if defined(OS_ANDROID)
   power_save_blocker_.reset();
 #endif
 }
 
 void RenderFrameDevToolsAgentHost::DidReceiveCompositorFrame() {
-  if (!session())
-    return;
   const cc::CompositorFrameMetadata& metadata =
       RenderWidgetHostImpl::From(
           web_contents()->GetRenderViewHost()->GetWidget())
           ->last_frame_metadata();
-  protocol::PageHandler* page_handler =
-      protocol::PageHandler::FromSession(session());
-  if (page_handler)
-    page_handler->OnSwapCompositorFrame(metadata.Clone());
-  protocol::InputHandler::FromSession(session())->OnSwapCompositorFrame(
-      metadata);
-  protocol::TracingHandler* tracing_handler =
-      protocol::TracingHandler::FromSession(session());
-  if (frame_trace_recorder_ && tracing_handler->did_initiate_recording()) {
+  for (auto* page : protocol::PageHandler::ForAgentHost(this))
+    page->OnSwapCompositorFrame(metadata.Clone());
+  for (auto* input : protocol::InputHandler::ForAgentHost(this))
+    input->OnSwapCompositorFrame(metadata);
+
+  if (!frame_trace_recorder_)
+    return;
+  bool did_initiate_recording = false;
+  for (auto* tracing : protocol::TracingHandler::ForAgentHost(this))
+    did_initiate_recording |= tracing->did_initiate_recording();
+  if (did_initiate_recording) {
     frame_trace_recorder_->OnSwapCompositorFrame(
         current_ ? current_->host() : nullptr, metadata);
   }
 }
 
 void RenderFrameDevToolsAgentHost::
     DispatchBufferedProtocolMessagesIfNecessary() {
   if (navigating_handles_.empty() &&
       in_navigation_protocol_message_buffer_.size()) {
     DCHECK(current_);
@@ skipping 157 matching lines @@
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame,
             dtah.get(),
             base::Passed(std::move(frame_metadata))));
   }
 }
 
 void RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame(
     cc::CompositorFrameMetadata frame_metadata) {
-  if (!session())
+  for (auto* page : protocol::PageHandler::ForAgentHost(this))
+    page->OnSynchronousSwapCompositorFrame(frame_metadata.Clone());
+  for (auto* input : protocol::InputHandler::ForAgentHost(this))
+    input->OnSwapCompositorFrame(frame_metadata);
+
+  if (!frame_trace_recorder_)
     return;
-  protocol::PageHandler* page_handler =
-      protocol::PageHandler::FromSession(session());
-  if (page_handler)
-    page_handler->OnSynchronousSwapCompositorFrame(std::move(frame_metadata));
-  protocol::InputHandler::FromSession(session())
-      ->OnSwapCompositorFrame(frame_metadata);
-  protocol::TracingHandler* tracing_handler =
-      protocol::TracingHandler::FromSession(session());
-  if (frame_trace_recorder_ && tracing_handler->did_initiate_recording()) {
+  bool did_initiate_recording = false;
+  for (auto* tracing : protocol::TracingHandler::ForAgentHost(this))
+    did_initiate_recording |= tracing->did_initiate_recording();
+  if (did_initiate_recording) {
     frame_trace_recorder_->OnSynchronousSwapCompositorFrame(
-        current_ ? current_->host() : nullptr,
-        frame_metadata);
+        current_ ? current_->host() : nullptr, frame_metadata);
   }
 }
 
 void RenderFrameDevToolsAgentHost::OnDispatchOnInspectorFrontend(
     RenderFrameHost* sender,
     const DevToolsMessageChunk& message) {
   bool success = true;
   if (current_ && current_->host() == sender)
     success = current_->ProcessChunkedMessageFromAgent(message);
   else if (pending_ && pending_->host() == sender)
@@ skipping 26 matching lines @@
     RenderFrameHost* host) {
   return (current_ && current_->host() == host) ||
       (pending_ && pending_->host() == host);
 }
 
 bool RenderFrameDevToolsAgentHost::IsChildFrame() {
   return current_ && current_->host()->GetParent();
 }
 
 }  // namespace content