[DevTools] Move Page and Emulation handlers to RenderFrameHostImpl.

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 "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/child_process_security_policy_impl.h"
@@ skipping 10 matching lines @@
 #include "content/browser/devtools/protocol/service_worker_handler.h"
 #include "content/browser/devtools/protocol/tracing_handler.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
-#include "content/public/browser/notification_service.h"
-#include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/web_contents_delegate.h"
 
 #if defined(OS_ANDROID)
 #include "content/browser/power_save_blocker_impl.h"
 #include "content/public/browser/render_widget_host_view.h"
 #endif
 
 namespace content {
 
@@ skipping 91 matching lines @@
   agent_host->DisconnectRenderFrameHost();
   agent_host->ConnectRenderFrameHost(current);
 }
 
 RenderFrameDevToolsAgentHost::RenderFrameDevToolsAgentHost(RenderFrameHost* rfh)
     : render_frame_host_(NULL),
       dom_handler_(new devtools::dom::DOMHandler()),
       input_handler_(new devtools::input::InputHandler()),
       inspector_handler_(new devtools::inspector::InspectorHandler()),
       network_handler_(new devtools::network::NetworkHandler()),
-      page_handler_(new devtools::page::PageHandler()),
+      page_handler_(nullptr),
       power_handler_(new devtools::power::PowerHandler()),
       service_worker_handler_(
           new devtools::service_worker::ServiceWorkerHandler()),
       tracing_handler_(new devtools::tracing::TracingHandler(
           devtools::tracing::TracingHandler::Renderer)),
-      emulation_handler_(new devtools::emulation::EmulationHandler(
-          page_handler_.get())),
+      emulation_handler_(nullptr),
       frame_trace_recorder_(new DevToolsFrameTraceRecorder()),
       reattaching_(false) {
   DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
   dispatcher->SetDOMHandler(dom_handler_.get());
-  dispatcher->SetEmulationHandler(emulation_handler_.get());
   dispatcher->SetInputHandler(input_handler_.get());
   dispatcher->SetInspectorHandler(inspector_handler_.get());
   dispatcher->SetNetworkHandler(network_handler_.get());
-  dispatcher->SetPageHandler(page_handler_.get());
   dispatcher->SetPowerHandler(power_handler_.get());
   dispatcher->SetServiceWorkerHandler(service_worker_handler_.get());
   dispatcher->SetTracingHandler(tracing_handler_.get());
+
+  if (!rfh->GetParent()) {
+    page_handler_.reset(new devtools::page::PageHandler());
+    emulation_handler_.reset(
+        new devtools::emulation::EmulationHandler(page_handler_.get()));
+    dispatcher->SetPageHandler(page_handler_.get());
+    dispatcher->SetEmulationHandler(emulation_handler_.get());
+  }
+
   SetRenderFrameHost(rfh);
   g_instances.Get().push_back(this);
   AddRef();  // Balanced in RenderFrameHostDestroyed.
   DevToolsManager::GetInstance()->AgentHostChanged(this);
 }
 
 BrowserContext* RenderFrameDevToolsAgentHost::GetBrowserContext() {
   WebContents* contents = web_contents();
   return contents ? contents->GetBrowserContext() : nullptr;
 }
@@ skipping 36 matching lines @@
     power_save_blocker_.get()->
         InitDisplaySleepBlocker(rvh->GetView()->GetNativeView());
   }
 #endif
 }
 
 void RenderFrameDevToolsAgentHost::OnClientDetached() {
 #if defined(OS_ANDROID)
   power_save_blocker_.reset();
 #endif
-  emulation_handler_->Detached();
-  page_handler_->Detached();
+  if (emulation_handler_)
+    emulation_handler_->Detached();
+  if (page_handler_)
+    page_handler_->Detached();
   power_handler_->Detached();
   service_worker_handler_->Detached();
   tracing_handler_->Detached();
   ClientDetachedFromRenderer();
 
   // TODO(kaznacheev): Move this call back to DevToolsManager when
   // extensions::ProcessManager no longer relies on this notification.
   if (!reattaching_)
     DevToolsAgentHostImpl::NotifyCallbacks(this, false);
 }
@@ skipping 126 matching lines @@
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderFrameDevToolsAgentHost, message)
     IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
                         OnDispatchOnInspectorFrontend)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void RenderFrameDevToolsAgentHost::DidAttachInterstitialPage() {
-  page_handler_->DidAttachInterstitialPage();
+  if (page_handler_)
+    page_handler_->DidAttachInterstitialPage();
 
   if (!render_frame_host_)
     return;
   // The rvh set in AboutToNavigateRenderFrame turned out to be interstitial.
   // Connect back to the real one.
   WebContents* web_contents =
     WebContents::FromRenderFrameHost(render_frame_host_);
   if (!web_contents)
     return;
   DisconnectRenderFrameHost();
   ConnectRenderFrameHost(web_contents->GetMainFrame());
 }
 
 void RenderFrameDevToolsAgentHost::DidDetachInterstitialPage() {
-  page_handler_->DidDetachInterstitialPage();
+  if (page_handler_)
+    page_handler_->DidDetachInterstitialPage();
 }
 
 void RenderFrameDevToolsAgentHost::TitleWasSet(
     NavigationEntry* entry, bool explicit_set) {
   DevToolsManager::GetInstance()->AgentHostChanged(this);
 }
 
 void RenderFrameDevToolsAgentHost::NavigationEntryCommitted(
     const LoadCommittedDetails& load_details) {
   DevToolsManager::GetInstance()->AgentHostChanged(this);
 }
 
 void RenderFrameDevToolsAgentHost::DidCommitProvisionalLoadForFrame(
     RenderFrameHost* render_frame_host,
     const GURL& url,
     ui::PageTransition transition_type) {
   service_worker_handler_->UpdateHosts();
 }
 
-void RenderFrameDevToolsAgentHost::Observe(int type,
-                                          const NotificationSource& source,
-                                          const NotificationDetails& details) {
-  if (type == content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED) {
-    bool visible = *Details<bool>(details).ptr();
-    page_handler_->OnVisibilityChanged(visible);
-  }
-}
-
 void RenderFrameDevToolsAgentHost::SetRenderFrameHost(RenderFrameHost* rfh) {
   DCHECK(ShouldCreateDevToolsFor(rfh));
   DCHECK(!render_frame_host_);
   render_frame_host_ = static_cast<RenderFrameHostImpl*>(rfh);
 
   WebContentsObserver::Observe(WebContents::FromRenderFrameHost(rfh));
   RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
       rfh->GetRenderViewHost());
   dom_handler_->SetRenderFrameHost(render_frame_host_);
-  emulation_handler_->SetRenderViewHost(rvh);
   input_handler_->SetRenderViewHost(rvh);
   network_handler_->SetRenderFrameHost(render_frame_host_);
-  page_handler_->SetRenderViewHost(rvh);
   service_worker_handler_->SetRenderFrameHost(render_frame_host_);
 
-  registrar_.Add(
-      this,
-      content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      content::Source<RenderWidgetHost>(rvh));
+  if (emulation_handler_)
+    emulation_handler_->SetRenderFrameHost(render_frame_host_);
+  if (page_handler_)
+    page_handler_->SetRenderFrameHost(render_frame_host_);
 }
 
 void RenderFrameDevToolsAgentHost::ClearRenderFrameHost() {
   DCHECK(render_frame_host_);
-  RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
-      render_frame_host_->GetRenderViewHost());
-  registrar_.Remove(
-      this,
-      content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      content::Source<RenderWidgetHost>(rvh));
   render_frame_host_ = nullptr;
   dom_handler_->SetRenderFrameHost(nullptr);
-  emulation_handler_->SetRenderViewHost(nullptr);
+  if (emulation_handler_)
+    emulation_handler_->SetRenderFrameHost(nullptr);
   input_handler_->SetRenderViewHost(nullptr);
   network_handler_->SetRenderFrameHost(nullptr);
-  page_handler_->SetRenderViewHost(nullptr);
+  if (page_handler_)
+    page_handler_->SetRenderFrameHost(nullptr);
   service_worker_handler_->SetRenderFrameHost(nullptr);
 }
 
 void RenderFrameDevToolsAgentHost::DisconnectWebContents() {
   DisconnectRenderFrameHost();
 }
 
 void RenderFrameDevToolsAgentHost::ConnectWebContents(WebContents* wc) {
   ConnectRenderFrameHost(wc->GetMainFrame());
 }
@@ skipping 48 matching lines @@
 
 void RenderFrameDevToolsAgentHost::RenderFrameCrashed() {
   inspector_handler_->TargetCrashed();
 }
 
 void RenderFrameDevToolsAgentHost::OnSwapCompositorFrame(
     const IPC::Message& message) {
   ViewHostMsg_SwapCompositorFrame::Param param;
   if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
     return;
-  page_handler_->OnSwapCompositorFrame(get<1>(param).metadata);
+  if (page_handler_)
+    page_handler_->OnSwapCompositorFrame(get<1>(param).metadata);
   frame_trace_recorder_->OnSwapCompositorFrame(
       render_frame_host_, get<1>(param).metadata);
 }
 
 void RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame(
     const cc::CompositorFrameMetadata& frame_metadata) {
   if (!render_frame_host_)
     return;
-  page_handler_->OnSwapCompositorFrame(frame_metadata);
+  if (page_handler_)
+    page_handler_->OnSwapCompositorFrame(frame_metadata);
   frame_trace_recorder_->OnSwapCompositorFrame(
       render_frame_host_, frame_metadata);
 }
 
 bool RenderFrameDevToolsAgentHost::HasRenderFrameHost(
     RenderFrameHost* host) {
   return host == render_frame_host_;
 }
 
 void RenderFrameDevToolsAgentHost::OnDispatchOnInspectorFrontend(
     const DevToolsMessageChunk& message) {
   if (!IsAttached() || !render_frame_host_)
     return;
   ProcessChunkedMessageFromAgent(message);
 }
 
 bool RenderFrameDevToolsAgentHost::IsChildFrame() {
   return render_frame_host_ && render_frame_host_->GetParent();
 }
 
 }  // namespace content