[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"
@@ skipping 80 matching lines @@
       screencast_quality_(kDefaultScreenshotQuality),
       screencast_max_width_(-1),
       screencast_max_height_(-1),
       capture_retry_count_(0),
       has_compositor_frame_metadata_(false),
       screencast_frame_sent_(0),
       screencast_frame_acked_(0),
       processing_screencast_frame_(false),
       color_picker_(new ColorPicker(base::Bind(
           &PageHandler::OnColorPicked, base::Unretained(this)))),
-      host_(nullptr),
+      web_contents_(nullptr),
       screencast_listener_(nullptr),
       weak_factory_(this) {
 }
 
 PageHandler::~PageHandler() {
 }
 
-void PageHandler::SetRenderViewHost(RenderViewHostImpl* host) {
-  if (host_ == host)
+void PageHandler::SetWebContents(WebContentsImpl* web_contents) {
+  if (web_contents_ == web_contents)
     return;
 
-  color_picker_->SetRenderViewHost(host);
-  host_ = host;
+  web_contents_ = web_contents;
+  color_picker_->SetRenderWidgetHost(GetRenderWidgetHost());
 }
 
 void PageHandler::SetClient(scoped_ptr<Client> client) {
   client_.swap(client);
 }
 
 void PageHandler::Detached() {
   Disable();
 }
 
@@ skipping 41 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_)
+  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())
+  if (!web_contents_->IsCrashed())
     return Response::FallThrough();
 
-  web_contents->GetController().Reload(false);
+  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_)
+  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()
+  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_)
+  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();
+  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_)
+  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();
+  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 (!web_contents_ || !web_contents_->GetRenderWidgetHostView())
     return Response::InternalError("Could not connect to view");
 
-  host_->GetSnapshotFromBrowser(
+  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_)
+  if (!web_contents_)
     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 = !GetRenderWidgetHost()->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 {
+      GetRenderWidgetHost()->Send(
+          new ViewMsg_ForceRedraw(GetRenderWidgetHost()->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_)
+  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);
+      web_contents_->GetDelegate()->GetJavaScriptDialogManager(web_contents_);
   if (manager && manager->HandleJavaScriptDialog(
-          web_contents, accept, prompt_text ? &prompt_override : nullptr)) {
+          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_)
+  if (!web_contents_)
     return Response::InternalError("Could not connect to view");
 
   color_picker_->SetEnabled(enabled);
   return Response::OK();
 }
 
+RenderWidgetHostImpl* PageHandler::GetRenderWidgetHost() {
+  // TODO(dgozman): there should be a way to get main RenderWidgetHost from
+  // WebContents without RenderViewHost.
+  return web_contents_ ?
+      static_cast<RenderViewHostImpl*>(web_contents_->GetRenderViewHost()) :
+      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_) {
     return;
   }
 
-  if (!host_ || !host_->GetView())
+  if (!web_contents_ || !web_contents_->GetRenderWidgetHostView())
     return;
 
   RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
-      host_->GetView());
+      web_contents_->GetRenderWidgetHostView());
   // TODO(vkuzkokov): do not use previous frame metadata.
   cc::CompositorFrameMetadata& metadata = last_compositor_frame_metadata_;
 
   gfx::SizeF viewport_size_dip = gfx::ScaleSize(
       metadata.scrollable_viewport_size, metadata.page_scale_factor);
   gfx::SizeF screen_size_dip = gfx::ScaleSize(view->GetPhysicalBackingSize(),
                                               1 / metadata.device_scale_factor);
 
   blink::WebScreenInfo screen_info;
   view->GetScreenInfo(&screen_info);
@@ skipping 53 matching lines @@
                  weak_factory_.GetWeakPtr(), metadata, base::Time::Now()));
 }
 
 void PageHandler::ScreencastFrameEncoded(
     const cc::CompositorFrameMetadata& metadata,
     const base::Time& timestamp,
     const std::string& data) {
   processing_screencast_frame_ = false;
 
   // Consider metadata empty in case it has no device scale factor.
-  if (metadata.device_scale_factor == 0 || !host_ || data.empty())
+  if (metadata.device_scale_factor == 0 || !web_contents_ || data.empty())
     return;
 
   RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
-      host_->GetView());
+      web_contents_->GetRenderWidgetHostView());
   if (!view)
     return;
 
   gfx::SizeF screen_size_dip = gfx::ScaleSize(
       view->GetPhysicalBackingSize(), 1 / metadata.device_scale_factor);
   scoped_refptr<ScreencastFrameMetadata> param_metadata =
       ScreencastFrameMetadata::Create()
           ->set_page_scale_factor(metadata.page_scale_factor)
           ->set_offset_top(metadata.location_bar_content_translation.y())
           ->set_device_width(screen_size_dip.width())
@@ skipping 27 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