[DevTools] Move Page and Emulation handlers to RenderFrameHostImpl.

content/browser/devtools/protocol/page_handler.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/protocol/page_handler.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/worker_pool.h"
 #include "content/browser/devtools/protocol/color_picker.h"
-#include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/javascript_dialog_manager.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/referrer.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/snapshot/snapshot.h"
@@ skipping 66 matching lines @@
       color_picker_(new ColorPicker(base::Bind(
           &PageHandler::OnColorPicked, base::Unretained(this)))),
       host_(nullptr),
       screencast_listener_(nullptr),
       weak_factory_(this) {
 }
 
 PageHandler::~PageHandler() {
 }
 
-void PageHandler::SetRenderViewHost(RenderViewHostImpl* host) {
+void PageHandler::SetRenderFrameHost(RenderFrameHostImpl* host) {
   if (host_ == host)
     return;
 
-  color_picker_->SetRenderViewHost(host);
+  RenderWidgetHostImpl* widget_host =
+      host_ ? host_->GetRenderWidgetHost() : nullptr;
+  if (widget_host) {
+    registrar_.Remove(
+        this,
+        content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
+        content::Source<RenderWidgetHost>(widget_host));
+  }
+
   host_ = host;
+  widget_host = host_ ? host_->GetRenderWidgetHost() : nullptr;
+  color_picker_->SetRenderWidgetHost(widget_host);
+
+  if (widget_host) {
+    registrar_.Add(
+        this,
+        content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
+        content::Source<RenderWidgetHost>(widget_host));
+  }
 }
 
 void PageHandler::SetClient(scoped_ptr<Client> client) {
   client_.swap(client);
 }
 
 void PageHandler::Detached() {
   Disable();
 }
 
 void PageHandler::OnSwapCompositorFrame(
     const cc::CompositorFrameMetadata& frame_metadata) {
   last_compositor_frame_metadata_ = has_compositor_frame_metadata_ ?
       next_compositor_frame_metadata_ : frame_metadata;
   next_compositor_frame_metadata_ = frame_metadata;
   has_compositor_frame_metadata_ = true;
 
   if (screencast_enabled_)
     InnerSwapCompositorFrame();
   color_picker_->OnSwapCompositorFrame();
 }
 
-void PageHandler::OnVisibilityChanged(bool visible) {
+void PageHandler::Observe(int type,
+                          const NotificationSource& source,
+                          const NotificationDetails& details) {
   if (!screencast_enabled_)
     return;
+  DCHECK(type == content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED);
+  bool visible = *Details<bool>(details).ptr();
   NotifyScreencastVisibility(visible);
 }
 
 void PageHandler::DidAttachInterstitialPage() {
   if (!enabled_)
     return;
   client_->InterstitialShown(InterstitialShownParams::Create());
 }
 
 void PageHandler::DidDetachInterstitialPage() {
@@ skipping 16 matching lines @@
   screencast_enabled_ = false;
   color_picker_->SetEnabled(false);
   if (screencast_listener_)
     screencast_listener_->ScreencastEnabledChanged();
   return Response::FallThrough();
 }
 
 Response PageHandler::Reload(const bool* ignoreCache,
                              const std::string* script_to_evaluate_on_load,
                              const std::string* script_preprocessor) {
-  if (!host_)
+  WebContentsImpl* web_contents = GetWebContents();
+  if (!web_contents)
     return Response::InternalError("Could not connect to view");
 
-  WebContents* web_contents = WebContents::FromRenderViewHost(host_);
-  if (!web_contents)
-    return Response::InternalError("No WebContents to reload");
-
   // Handle in browser only if it is crashed.
   if (!web_contents->IsCrashed())
     return Response::FallThrough();
 
   web_contents->GetController().Reload(false);
   return Response::OK();
 }
 
 Response PageHandler::Navigate(const std::string& url,
                                FrameId* frame_id) {
   GURL gurl(url);
   if (!gurl.is_valid())
     return Response::InternalError("Cannot navigate to invalid URL");
 
-  if (!host_)
+  WebContentsImpl* web_contents = GetWebContents();
+  if (!web_contents)
     return Response::InternalError("Could not connect to view");
 
-  WebContents* web_contents = WebContents::FromRenderViewHost(host_);
-  if (!web_contents)
-    return Response::InternalError("No WebContents to navigate");
-
   web_contents->GetController()
       .LoadURL(gurl, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   return Response::FallThrough();
 }
 
 Response PageHandler::GetNavigationHistory(int* current_index,
                                            NavigationEntries* entries) {
-  if (!host_)
+  WebContentsImpl* web_contents = GetWebContents();
+  if (!web_contents)
     return Response::InternalError("Could not connect to view");
 
-  WebContents* web_contents = WebContents::FromRenderViewHost(host_);
-  if (!web_contents)
-    return Response::InternalError("No WebContents to navigate");
-
   NavigationController& controller = web_contents->GetController();
   *current_index = controller.GetCurrentEntryIndex();
   for (int i = 0; i != controller.GetEntryCount(); ++i) {
     entries->push_back(NavigationEntry::Create()
         ->set_id(controller.GetEntryAtIndex(i)->GetUniqueID())
         ->set_url(controller.GetEntryAtIndex(i)->GetURL().spec())
         ->set_title(
             base::UTF16ToUTF8(controller.GetEntryAtIndex(i)->GetTitle())));
   }
   return Response::OK();
 }
 
 Response PageHandler::NavigateToHistoryEntry(int entry_id) {
-  if (!host_)
+  WebContentsImpl* web_contents = GetWebContents();
+  if (!web_contents)
     return Response::InternalError("Could not connect to view");
 
-  WebContents* web_contents = WebContents::FromRenderViewHost(host_);
-  if (!web_contents)
-    return Response::InternalError("No WebContents to navigate");
-
   NavigationController& controller = web_contents->GetController();
   for (int i = 0; i != controller.GetEntryCount(); ++i) {
     if (controller.GetEntryAtIndex(i)->GetUniqueID() == entry_id) {
       controller.GoToIndex(i);
       return Response::OK();
     }
   }
 
   return Response::InvalidParams("No entry with passed id");
 }
 
 Response PageHandler::CaptureScreenshot(DevToolsCommandId command_id) {
-  if (!host_ || !host_->GetView())
+  if (!host_ || !host_->GetRenderWidgetHost())
     return Response::InternalError("Could not connect to view");
 
-  host_->GetSnapshotFromBrowser(
+  host_->GetRenderWidgetHost()->GetSnapshotFromBrowser(
       base::Bind(&PageHandler::ScreenshotCaptured,
           weak_factory_.GetWeakPtr(), command_id));
   return Response::OK();
 }
 
 Response PageHandler::CanScreencast(bool* result) {
 #if defined(OS_ANDROID)
   *result = true;
 #else
   *result = false;
 #endif  // defined(OS_ANDROID)
   return Response::OK();
 }
 
 Response PageHandler::StartScreencast(const std::string* format,
                                       const int* quality,
                                       const int* max_width,
                                       const int* max_height) {
-  if (!host_)
+  RenderWidgetHostImpl* widget_host =
+      host_ ? host_->GetRenderWidgetHost() : nullptr;
+  if (!widget_host)
     return Response::InternalError("Could not connect to view");
 
   screencast_enabled_ = true;
   screencast_format_ = format ? *format : kPng;
   screencast_quality_ = quality ? *quality : kDefaultScreenshotQuality;
   if (screencast_quality_ < 0 || screencast_quality_ > 100)
     screencast_quality_ = kDefaultScreenshotQuality;
   screencast_max_width_ = max_width ? *max_width : -1;
   screencast_max_height_ = max_height ? *max_height : -1;
 
-  bool visible = !host_->is_hidden();
+  bool visible = !widget_host->is_hidden();
   NotifyScreencastVisibility(visible);
   if (visible) {
-    if (has_compositor_frame_metadata_)
+    if (has_compositor_frame_metadata_) {
       InnerSwapCompositorFrame();
-    else
-      host_->Send(new ViewMsg_ForceRedraw(host_->GetRoutingID(), 0));
+    } else {
+      widget_host->Send(
+          new ViewMsg_ForceRedraw(widget_host->GetRoutingID(), 0));
+    }
   }
   if (screencast_listener_)
     screencast_listener_->ScreencastEnabledChanged();
   return Response::FallThrough();
 }
 
 Response PageHandler::StopScreencast() {
   screencast_enabled_ = false;
   if (screencast_listener_)
     screencast_listener_->ScreencastEnabledChanged();
   return Response::FallThrough();
 }
 
 Response PageHandler::ScreencastFrameAck(int frame_number) {
   screencast_frame_acked_ = frame_number;
   return Response::OK();
 }
 
 Response PageHandler::HandleJavaScriptDialog(bool accept,
                                              const std::string* prompt_text) {
   base::string16 prompt_override;
   if (prompt_text)
     prompt_override = base::UTF8ToUTF16(*prompt_text);
 
-  if (!host_)
+  WebContentsImpl* web_contents = GetWebContents();
+  if (!web_contents)
     return Response::InternalError("Could not connect to view");
 
-  WebContents* web_contents = WebContents::FromRenderViewHost(host_);
-  if (!web_contents)
-    return Response::InternalError("No JavaScript dialog to handle");
-
   JavaScriptDialogManager* manager =
       web_contents->GetDelegate()->GetJavaScriptDialogManager(web_contents);
   if (manager && manager->HandleJavaScriptDialog(
           web_contents, accept, prompt_text ? &prompt_override : nullptr)) {
     return Response::OK();
   }
 
   return Response::InternalError("Could not handle JavaScript dialog");
 }
 
 Response PageHandler::QueryUsageAndQuota(DevToolsCommandId command_id,
                                          const std::string& security_origin) {
   return Response::OK();
 }
 
 Response PageHandler::SetColorPickerEnabled(bool enabled) {
   if (!host_)
     return Response::InternalError("Could not connect to view");
 
   color_picker_->SetEnabled(enabled);
   return Response::OK();
 }
 
+WebContentsImpl* PageHandler::GetWebContents() {
+  return host_ ?
+      static_cast<WebContentsImpl*>(WebContents::FromRenderFrameHost(host_)) :
+      nullptr;
+}
+
 void PageHandler::NotifyScreencastVisibility(bool visible) {
   if (visible)
     capture_retry_count_ = kCaptureRetryLimit;
   client_->ScreencastVisibilityChanged(
       ScreencastVisibilityChangedParams::Create()->set_visible(visible));
 }
 
 void PageHandler::InnerSwapCompositorFrame() {
   if (screencast_frame_sent_ - screencast_frame_acked_ >
       kMaxScreencastFramesInFlight || processing_screencast_frame_) {
@@ skipping 123 matching lines @@
 
 void PageHandler::OnColorPicked(int r, int g, int b, int a) {
   scoped_refptr<dom::RGBA> color =
       dom::RGBA::Create()->set_r(r)->set_g(g)->set_b(b)->set_a(a);
   client_->ColorPicked(ColorPickedParams::Create()->set_color(color));
 }
 
 }  // namespace page
 }  // namespace devtools
 }  // namespace content