[DevTools] Rework DevToolsSession interaction with 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"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/devtools_frame_trace_recorder.h"
 #include "content/browser/devtools/devtools_manager.h"
 #include "content/browser/devtools/devtools_session.h"
 #include "content/browser/devtools/page_navigation_throttle.h"
 #include "content/browser/devtools/protocol/dom_handler.h"
 #include "content/browser/devtools/protocol/emulation_handler.h"
@@ skipping 73 matching lines @@
 // RenderFrameDevToolsAgentHost::FrameHostHolder -------------------------------
 
 class RenderFrameDevToolsAgentHost::FrameHostHolder {
  public:
   FrameHostHolder(
       RenderFrameDevToolsAgentHost* agent, RenderFrameHostImpl* host);
   ~FrameHostHolder();
 
   RenderFrameHostImpl* host() const { return host_; }
 
-  void Attach();
+  void Attach(DevToolsSession* session);
   void Reattach(FrameHostHolder* old);
-  void Detach();
+  void Detach(int session_id);
   void DispatchProtocolMessage(int session_id,
                                int call_id,
                                const std::string& method,
                                const std::string& message);
   void InspectElement(int session_id, int x, int y);
   bool ProcessChunkedMessageFromAgent(const DevToolsMessageChunk& chunk);
   void Suspend();
   void Resume();
 
  private:
@@ skipping 25 matching lines @@
            base::Unretained(this))) {
   DCHECK(agent_);
   DCHECK(host_);
 }
 
 RenderFrameDevToolsAgentHost::FrameHostHolder::~FrameHostHolder() {
   if (attached_)
     RevokePolicy();
 }
 
-void RenderFrameDevToolsAgentHost::FrameHostHolder::Attach() {
+void RenderFrameDevToolsAgentHost::FrameHostHolder::Attach(
+    DevToolsSession* session) {
   host_->Send(new DevToolsAgentMsg_Attach(
-      host_->GetRoutingID(), agent_->GetId(), agent_->session()->session_id()));
+      host_->GetRoutingID(), agent_->GetId(), session->session_id()));
   GrantPolicy();
   attached_ = true;
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::Reattach(
     FrameHostHolder* old) {
   if (old)
     chunk_processor_.set_state_cookie(old->chunk_processor_.state_cookie());
   host_->Send(new DevToolsAgentMsg_Reattach(
       host_->GetRoutingID(), agent_->GetId(), agent_->session()->session_id(),
       chunk_processor_.state_cookie()));
   if (old) {
     if (IsBrowserSideNavigationEnabled()) {
       for (const auto& pair :
                old->sent_messages_whose_reply_came_while_suspended_) {
         DispatchProtocolMessage(pair.second.session_id, pair.first,
                                 pair.second.method, pair.second.message);
       }
     }
     for (const auto& pair : old->sent_messages_) {
       DispatchProtocolMessage(pair.second.session_id, pair.first,
                               pair.second.method, pair.second.message);
     }
   }
   GrantPolicy();
   attached_ = true;
 }
 
-void RenderFrameDevToolsAgentHost::FrameHostHolder::Detach() {
+void RenderFrameDevToolsAgentHost::FrameHostHolder::Detach(int session_id) {
   host_->Send(new DevToolsAgentMsg_Detach(host_->GetRoutingID()));
   RevokePolicy();
   attached_ = false;
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::GrantPolicy() {
   ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadRawCookies(
       host_->GetProcess()->GetID());
 }
 
@@ skipping 178 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->page_handler_) {
-    return agent_host->page_handler_->CreateThrottleForNavigation(
-        navigation_handle);
-  }
-  return nullptr;
+  if (!agent_host || !agent_host->session())
+    return nullptr;
+  protocol::PageHandler* page_handler =
+      protocol::PageHandler::FromSession(agent_host->session());
+  if (!page_handler)
+    return nullptr;
+  return page_handler->CreateThrottleForNavigation(navigation_handle);
 }
 
 // static
 bool RenderFrameDevToolsAgentHost::IsNetworkHandlerEnabled(
     FrameTreeNode* frame_tree_node) {
   RenderFrameDevToolsAgentHost* agent_host = FindAgentHost(frame_tree_node);
-  return agent_host && agent_host->network_handler_ &&
-         agent_host->network_handler_->enabled();
+  if (!agent_host || !agent_host->session())
+    return false;
+  return protocol::NetworkHandler::FromSession(agent_host->session())
+      ->enabled();
 }
 
 // static
 std::string RenderFrameDevToolsAgentHost::UserAgentOverride(
     FrameTreeNode* frame_tree_node) {
   RenderFrameDevToolsAgentHost* agent_host = FindAgentHost(frame_tree_node);
-  if (agent_host && agent_host->network_handler_)
-    return agent_host->network_handler_->UserAgentOverride();
-  return std::string();
+  if (!agent_host || !agent_host->session())
+    return std::string();
+  return protocol::NetworkHandler::FromSession(agent_host->session())
+      ->UserAgentOverride();
 }
 
 // static
 void RenderFrameDevToolsAgentHost::WebContentsCreated(
     WebContents* web_contents) {
   if (ShouldForceCreation()) {
     // Force agent host.
     DevToolsAgentHost::GetOrCreateFor(web_contents);
   }
 }
@@ skipping 60 matching lines @@
 
 BrowserContext* RenderFrameDevToolsAgentHost::GetBrowserContext() {
   WebContents* contents = web_contents();
   return contents ? contents->GetBrowserContext() : nullptr;
 }
 
 WebContents* RenderFrameDevToolsAgentHost::GetWebContents() {
   return web_contents();
 }
 
-void RenderFrameDevToolsAgentHost::Attach() {
-  session()->dispatcher()->setFallThroughForNotFound(true);
-
+void RenderFrameDevToolsAgentHost::AttachSession(DevToolsSession* session) {
+  session->SetFallThroughForNotFound(true);
+  session->SetRenderFrameHost(handlers_frame_host_);
   if (!frame_tree_node_->parent()) {
-    emulation_handler_.reset(new protocol::EmulationHandler());
-    emulation_handler_->Wire(session()->dispatcher());
-    emulation_handler_->SetRenderFrameHost(handlers_frame_host_);
+    session->AddHandler(base::WrapUnique(new protocol::EmulationHandler()));
+    session->AddHandler(base::WrapUnique(new protocol::PageHandler()));
+    session->AddHandler(base::WrapUnique(new protocol::SecurityHandler()));
   }
-
-  dom_handler_.reset(new protocol::DOMHandler());
-  dom_handler_->Wire(session()->dispatcher());
-  dom_handler_->SetRenderFrameHost(handlers_frame_host_);
-
-  input_handler_.reset(new protocol::InputHandler());
-  input_handler_->Wire(session()->dispatcher());
-  input_handler_->SetRenderFrameHost(handlers_frame_host_);
-
-  inspector_handler_.reset(new protocol::InspectorHandler());
-  inspector_handler_->Wire(session()->dispatcher());
-  inspector_handler_->SetRenderFrameHost(handlers_frame_host_);
-
-  io_handler_.reset(new protocol::IOHandler(GetIOContext()));
-  io_handler_->Wire(session()->dispatcher());
-
-  network_handler_.reset(new protocol::NetworkHandler());
-  network_handler_->Wire(session()->dispatcher());
-  network_handler_->SetRenderFrameHost(handlers_frame_host_);
-
-  if (!frame_tree_node_->parent()) {
-    page_handler_.reset(new protocol::PageHandler());
-    page_handler_->Wire(session()->dispatcher());
-    page_handler_->SetRenderFrameHost(handlers_frame_host_);
-  }
-
-  schema_handler_.reset(new protocol::SchemaHandler());
-  schema_handler_->Wire(session()->dispatcher());
-
-  if (!frame_tree_node_->parent()) {
-    security_handler_.reset(new protocol::SecurityHandler());
-    security_handler_->Wire(session()->dispatcher());
-    security_handler_->SetRenderFrameHost(handlers_frame_host_);
-  }
-
-  service_worker_handler_.reset(new protocol::ServiceWorkerHandler());
-  service_worker_handler_->Wire(session()->dispatcher());
-  service_worker_handler_->SetRenderFrameHost(handlers_frame_host_);
-
-  storage_handler_.reset(new protocol::StorageHandler());
-  storage_handler_->Wire(session()->dispatcher());
-  storage_handler_->SetRenderFrameHost(handlers_frame_host_);
-
-  target_handler_.reset(new protocol::TargetHandler());
-  target_handler_->Wire(session()->dispatcher());
-  target_handler_->SetRenderFrameHost(handlers_frame_host_);
-
-  tracing_handler_.reset(new protocol::TracingHandler(
+  session->AddHandler(base::WrapUnique(new protocol::DOMHandler()));
+  session->AddHandler(base::WrapUnique(new protocol::InputHandler()));
+  session->AddHandler(base::WrapUnique(new protocol::InspectorHandler()));
+  session->AddHandler(base::WrapUnique(new protocol::IOHandler(
+      GetIOContext())));
+  session->AddHandler(base::WrapUnique(new protocol::NetworkHandler()));
+  session->AddHandler(base::WrapUnique(new protocol::SchemaHandler()));
+  session->AddHandler(base::WrapUnique(new protocol::ServiceWorkerHandler()));
+  session->AddHandler(base::WrapUnique(new protocol::StorageHandler()));
+  session->AddHandler(base::WrapUnique(new protocol::TargetHandler()));
+  session->AddHandler(base::WrapUnique(new protocol::TracingHandler(
       protocol::TracingHandler::Renderer,
       frame_tree_node_->frame_tree_node_id(),
-      GetIOContext()));
-  tracing_handler_->Wire(session()->dispatcher());
+      GetIOContext())));
 
   if (current_)
-    current_->Attach();
+    current_->Attach(session);
   if (pending_)
-    pending_->Attach();
+    pending_->Attach(session);
   OnClientAttached();
 }
 
-void RenderFrameDevToolsAgentHost::Detach() {
-  dom_handler_->Disable();
-  dom_handler_.reset();
-  if (emulation_handler_) {
-    emulation_handler_->Disable();
-    emulation_handler_.reset();
-  }
-  input_handler_->Disable();
-  input_handler_.reset();
-  inspector_handler_->Disable();
-  inspector_handler_.reset();
-  io_handler_->Disable();
-  io_handler_.reset();
-  network_handler_->Disable();
-  network_handler_.reset();
-  if (page_handler_) {
-    page_handler_->Disable();
-    page_handler_.reset();
-  }
-  schema_handler_->Disable();
-  schema_handler_.reset();
-  if (security_handler_) {
-    security_handler_->Disable();
-    security_handler_.reset();
-  }
-  service_worker_handler_->Disable();
-  service_worker_handler_.reset();
-  storage_handler_->Disable();
-  storage_handler_.reset();
-  target_handler_->Disable();
-  target_handler_.reset();
-  tracing_handler_->Disable();
-  tracing_handler_.reset();
-
+void RenderFrameDevToolsAgentHost::DetachSession(int session_id) {
   if (current_)
-    current_->Detach();
+    current_->Detach(session_id);
   if (pending_)
-    pending_->Detach();
+    pending_->Detach(session_id);
   OnClientDetached();
 }
 
 bool RenderFrameDevToolsAgentHost::DispatchProtocolMessage(
+    DevToolsSession* session,
     const std::string& message) {
   int call_id = 0;
   std::string method;
-  if (session()->Dispatch(message, &call_id, &method) !=
+  if (session->Dispatch(message, true, &call_id, &method) !=
       protocol::Response::kFallThrough) {
     return true;
   }
 
   if (!navigating_handles_.empty()) {
     DCHECK(IsBrowserSideNavigationEnabled());
     in_navigation_protocol_message_buffer_[call_id] =
-        { session()->session_id(), method, message };
+        { session->session_id(), method, message };
     return true;
   }
 
   if (current_) {
     current_->DispatchProtocolMessage(
-        session()->session_id(), call_id, method, message);
+        session->session_id(), call_id, method, message);
   }
   if (pending_) {
     pending_->DispatchProtocolMessage(
-        session()->session_id(), call_id, method, message);
+        session->session_id(), call_id, method, message);
   }
   return true;
 }
 
-void RenderFrameDevToolsAgentHost::InspectElement(int x, int y) {
+void RenderFrameDevToolsAgentHost::InspectElement(
+    DevToolsSession* session,
+    int x,
+    int y) {
   if (current_)
-    current_->InspectElement(session()->session_id(), x, y);
+    current_->InspectElement(session->session_id(), x, y);
   if (pending_)
-    pending_->InspectElement(session()->session_id(), x, y);
+    pending_->InspectElement(session->session_id(), x, y);
 }
 
 void RenderFrameDevToolsAgentHost::OnClientAttached() {
   if (!web_contents())
     return;
 
   frame_trace_recorder_.reset(new DevToolsFrameTraceRecorder());
   CreatePowerSaveBlocker();
 }
 
@@ skipping 69 matching lines @@
     } else {
       DiscardPending();
     }
     pending_handle_ = nullptr;
   } else if (navigating_handles_.empty()) {
     current_->Resume();
   }
   DispatchBufferedProtocolMessagesIfNecessary();
 
   DCHECK(CheckConsistency());
-  if (target_handler_ && navigation_handle->HasCommitted())
-    target_handler_->UpdateServiceWorkers();
+  if (session() && navigation_handle->HasCommitted())
+    protocol::TargetHandler::FromSession(session())->UpdateServiceWorkers();
 }
 
 void RenderFrameDevToolsAgentHost::AboutToNavigateRenderFrame(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
 
   if (IsBrowserSideNavigationEnabled())
     return;
@@ skipping 25 matching lines @@
   current_->Suspend();
   DCHECK(CheckConsistency());
 }
 
 void RenderFrameDevToolsAgentHost::RenderFrameHostChanged(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
 
-  if (target_handler_)
-    target_handler_->UpdateFrames();
+  if (session())
+    protocol::TargetHandler::FromSession(session())->UpdateFrames();
 
   if (IsBrowserSideNavigationEnabled())
     return;
 
   DCHECK(!pending_ || pending_->host() != old_host);
   if (!current_ || current_->host() != old_host) {
     DCHECK(CheckConsistency());
     return;
   }
 
@@ skipping 23 matching lines @@
   else
     DCHECK(CheckConsistency());
 }
 
 void RenderFrameDevToolsAgentHost::DestroyOnRenderFrameGone() {
   DCHECK(current_);
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
   UpdateProtocolHandlers(nullptr);
   if (IsAttached())
     OnClientDetached();
-  HostClosed();
+  ForceDetach(false);
   pending_.reset();
   current_.reset();
   frame_tree_node_ = nullptr;
   pending_handle_ = nullptr;
   WebContentsObserver::Observe(nullptr);
   Release();
 }
 
 bool RenderFrameDevToolsAgentHost::CheckConsistency() {
   if (current_ && pending_ && current_->host() == pending_->host())
@@ skipping 27 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 (inspector_handler_)
-        inspector_handler_->TargetCrashed();
+      if (session())
+        protocol::InspectorHandler::FromSession(session())->TargetCrashed();
       current_frame_crashed_ = true;
       break;
     default:
-      if (inspector_handler_)
-        inspector_handler_->TargetDetached("Render process gone.");
+      if (session()) {
+        protocol::InspectorHandler::FromSession(session())
+            ->TargetDetached("Render process gone.");
+      }
       break;
   }
   DCHECK(CheckConsistency());
 }
 
 bool RenderFrameDevToolsAgentHost::OnMessageReceived(
     const IPC::Message& message) {
   if (!current_)
     return false;
   if (message.type() == ViewHostMsg_SwapCompositorFrame::ID)
@@ skipping 16 matching lines @@
     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() {
-  if (page_handler_)
-    page_handler_->DidAttachInterstitialPage();
+  protocol::PageHandler* page_handler =
+      session() ? protocol::PageHandler::FromSession(session()) : nullptr;
+  if (page_handler)
+    page_handler->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() {
-  if (page_handler_)
-    page_handler_->DidDetachInterstitialPage();
+  protocol::PageHandler* page_handler =
+      session() ? protocol::PageHandler::FromSession(session()) : nullptr;
+  if (page_handler)
+    page_handler->DidDetachInterstitialPage();
 }
 
 void RenderFrameDevToolsAgentHost::DidCommitProvisionalLoadForFrame(
     RenderFrameHost* render_frame_host,
     const GURL& url,
     ui::PageTransition transition_type) {
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
 
   if (IsBrowserSideNavigationEnabled())
     return;
   if (pending_ && pending_->host() == render_frame_host)
     CommitPending();
   DCHECK(CheckConsistency());
-  if (target_handler_)
-    target_handler_->UpdateServiceWorkers();
+  if (session())
+    protocol::TargetHandler::FromSession(session())->UpdateServiceWorkers();
 }
 
 void RenderFrameDevToolsAgentHost::DidFailProvisionalLoad(
     RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     int error_code,
     const base::string16& error_description,
     bool was_ignored_by_handler) {
   if (IsBrowserSideNavigationEnabled())
     return;
@@ skipping 28 matching lines @@
 
 void RenderFrameDevToolsAgentHost::UpdateProtocolHandlers(
     RenderFrameHostImpl* host) {
 #if DCHECK_IS_ON()
   // Check that we don't have stale host object here by accessing some random
   // properties inside.
   if (handlers_frame_host_ && handlers_frame_host_->GetRenderWidgetHost())
     handlers_frame_host_->GetRenderWidgetHost()->GetRoutingID();
 #endif
   handlers_frame_host_ = host;
-  if (dom_handler_)
-    dom_handler_->SetRenderFrameHost(host);
-  if (emulation_handler_)
-    emulation_handler_->SetRenderFrameHost(host);
-  if (input_handler_)
-    input_handler_->SetRenderFrameHost(host);
-  if (inspector_handler_)
-    inspector_handler_->SetRenderFrameHost(host);
-  if (network_handler_)
-    network_handler_->SetRenderFrameHost(host);
-  if (page_handler_)
-    page_handler_->SetRenderFrameHost(host);
-  if (service_worker_handler_)
-    service_worker_handler_->SetRenderFrameHost(host);
-  if (security_handler_)
-    security_handler_->SetRenderFrameHost(host);
-  if (storage_handler_)
-    storage_handler_->SetRenderFrameHost(host);
-  if (target_handler_)
-    target_handler_->SetRenderFrameHost(host);
+  if (session())
+    session()->SetRenderFrameHost(host);
 }
 
 void RenderFrameDevToolsAgentHost::DisconnectWebContents() {
   if (pending_)
     DiscardPending();
   UpdateProtocolHandlers(nullptr);
   disconnected_ = std::move(current_);
-  disconnected_->Detach();
+  if (session())
+    disconnected_->Detach(session()->session_id());
   frame_tree_node_ = nullptr;
   in_navigation_protocol_message_buffer_.clear();
   navigating_handles_.clear();
   pending_handle_ = nullptr;
   WebContentsObserver::Observe(nullptr);
 }
 
 void RenderFrameDevToolsAgentHost::ConnectWebContents(WebContents* wc) {
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
@@ skipping 109 matching lines @@
   if (content::WebContents* contents = web_contents())
     return contents->GetLastActiveTime();
   return base::TimeTicks();
 }
 
 void RenderFrameDevToolsAgentHost::OnSwapCompositorFrame(
     const IPC::Message& message) {
   ViewHostMsg_SwapCompositorFrame::Param param;
   if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
     return;
-  if (page_handler_) {
-    page_handler_->OnSwapCompositorFrame(
+  if (!session())
+    return;
+  protocol::PageHandler* page_handler =
+      protocol::PageHandler::FromSession(session());
+  if (page_handler) {
+    page_handler->OnSwapCompositorFrame(
         std::move(std::get<1>(param).metadata));
   }
-  if (input_handler_)
-    input_handler_->OnSwapCompositorFrame(std::get<1>(param).metadata);
-  if (frame_trace_recorder_ && tracing_handler_->did_initiate_recording()) {
+  protocol::InputHandler::FromSession(session())
+      ->OnSwapCompositorFrame(std::get<1>(param).metadata);
+  protocol::TracingHandler* tracing_handler =
+      protocol::TracingHandler::FromSession(session());
+  if (frame_trace_recorder_ && tracing_handler->did_initiate_recording()) {
     frame_trace_recorder_->OnSwapCompositorFrame(
         current_ ? current_->host() : nullptr, std::get<1>(param).metadata);
   }
 }
 
 void RenderFrameDevToolsAgentHost::SignalSynchronousSwapCompositorFrame(
     RenderFrameHost* frame_host,
     cc::CompositorFrameMetadata frame_metadata) {
   scoped_refptr<RenderFrameDevToolsAgentHost> dtah(FindAgentHost(frame_host));
   if (dtah) {
     // Unblock the compositor.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame,
             dtah.get(),
             base::Passed(std::move(frame_metadata))));
   }
 }
 
 void RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame(
     cc::CompositorFrameMetadata frame_metadata) {
-  if (page_handler_)
-    page_handler_->OnSynchronousSwapCompositorFrame(std::move(frame_metadata));
-  if (input_handler_)
-    input_handler_->OnSwapCompositorFrame(frame_metadata);
-  if (frame_trace_recorder_ && tracing_handler_->did_initiate_recording()) {
+  if (!session())
+    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()) {
     frame_trace_recorder_->OnSynchronousSwapCompositorFrame(
         current_ ? current_->host() : nullptr,
         frame_metadata);
   }
 }
 
 void RenderFrameDevToolsAgentHost::OnDispatchOnInspectorFrontend(
     RenderFrameHost* sender,
     const DevToolsMessageChunk& message) {
   bool success = true;
@@ skipping 29 matching lines @@
     RenderFrameHost* host) {
   return (current_ && current_->host() == host) ||
       (pending_ && pending_->host() == host);
 }
 
 bool RenderFrameDevToolsAgentHost::IsChildFrame() {
   return current_ && current_->host()->GetParent();
 }
 
 }  // namespace content