[DevTools] Move Page and Emulation handlers to RenderFrameHostImpl.

content/browser/devtools/protocol/emulation_handler.cc

 // Copyright 2015 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/emulation_handler.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/geolocation/geolocation_service_context.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
@@ skipping 22 matching lines @@
   }
   return result;
 }
 
 }  // namespace
 
 EmulationHandler::EmulationHandler(page::PageHandler* page_handler)
     : touch_emulation_enabled_(false),
       device_emulation_enabled_(false),
       page_handler_(page_handler),
-      host_(nullptr)
+      web_contents_(nullptr)
 {
   page_handler->SetScreencastListener(this);
 }
 
 EmulationHandler::~EmulationHandler() {
 }
 
 void EmulationHandler::ScreencastEnabledChanged() {
    UpdateTouchEventEmulationState();
 }
 
-void EmulationHandler::SetRenderViewHost(RenderViewHostImpl* host) {
-  if (host_ == host)
+void EmulationHandler::SetWebContents(WebContentsImpl* web_contents) {
+  if (web_contents_ == web_contents)
     return;
 
-  host_ = host;
+  web_contents_ = web_contents;
   UpdateTouchEventEmulationState();
   UpdateDeviceEmulationState();
 }
 
 void EmulationHandler::Detached() {
   touch_emulation_enabled_ = false;
   device_emulation_enabled_ = false;
   UpdateTouchEventEmulationState();
   UpdateDeviceEmulationState();
 }
 
 Response EmulationHandler::SetGeolocationOverride(
     double* latitude, double* longitude, double* accuracy) {
-  if (!host_)
+  if (!web_contents_)
     return Response::InternalError("Could not connect to view");
 
-  WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
-      WebContents::FromRenderViewHost(host_));
-  if (!web_contents)
-    return Response::InternalError("No WebContents to override");
-
   GeolocationServiceContext* geolocation_context =
-      web_contents->GetGeolocationServiceContext();
+      web_contents_->GetGeolocationServiceContext();
   scoped_ptr<Geoposition> geoposition(new Geoposition());
   if (latitude && longitude && accuracy) {
     geoposition->latitude = *latitude;
     geoposition->longitude = *longitude;
     geoposition->accuracy = *accuracy;
     geoposition->timestamp = base::Time::Now();
     if (!geoposition->Validate()) {
       return Response::InternalError("Invalid geolocation");
     }
   } else {
     geoposition->error_code = Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
   }
   geolocation_context->SetOverride(geoposition.Pass());
   return Response::OK();
 }
 
 Response EmulationHandler::ClearGeolocationOverride() {
-  if (!host_)
+  if (!web_contents_)
     return Response::InternalError("Could not connect to view");
 
-  WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
-      WebContents::FromRenderViewHost(host_));
-  if (!web_contents)
-    return Response::InternalError("No WebContents to override");
-
   GeolocationServiceContext* geolocation_context =
-      web_contents->GetGeolocationServiceContext();
+      web_contents_->GetGeolocationServiceContext();
   geolocation_context->ClearOverride();
   return Response::OK();
 }
 
 Response EmulationHandler::SetTouchEmulationEnabled(
     bool enabled, const std::string* configuration) {
   touch_emulation_enabled_ = enabled;
   touch_emulation_configuration_ =
       configuration ? *configuration : std::string();
   UpdateTouchEventEmulationState();
   return Response::FallThrough();
 }
 
 Response EmulationHandler::CanEmulate(bool* result) {
 #if defined(OS_ANDROID)
   *result = false;
 #else
-  if (host_) {
-    if (WebContents* web_contents = WebContents::FromRenderViewHost(host_)) {
-      *result = web_contents->GetMainFrame()->GetRenderViewHost() == host_;
+  if (web_contents_) {
+    *result = true;
 #if defined(DEBUG_DEVTOOLS)
-      *result &= !web_contents->GetVisibleURL().SchemeIs(kChromeDevToolsScheme);
+    *result &= !web_contents_->GetVisibleURL().SchemeIs(kChromeDevToolsScheme);
 #endif  // defined(DEBUG_DEVTOOLS)
-    } else {
-      *result = true;
-    }
   } else {
     *result = true;
   }
 #endif  // defined(OS_ANDROID)
   return Response::OK();
 }
 
 Response EmulationHandler::SetDeviceMetricsOverride(
     int width, int height, double device_scale_factor, bool mobile,
     bool fit_window, const double* optional_scale,
     const double* optional_offset_x, const double* optional_offset_y) {
   const static int max_size = 10000000;
   const static double max_scale = 10;
 
-  if (!host_)
+  if (!web_contents_)
     return Response::InternalError("Could not connect to view");
 
   if (width < 0 || height < 0 || width > max_size || height > max_size) {
     return Response::InvalidParams(
         "Width and height values must be positive, not greater than " +
         base::IntToString(max_size));
   }
 
   if (device_scale_factor < 0)
     return Response::InvalidParams("deviceScaleFactor must be non-negative");
@@ skipping 26 matching lines @@
 
 Response EmulationHandler::ClearDeviceMetricsOverride() {
   if (!device_emulation_enabled_)
     return Response::OK();
 
   device_emulation_enabled_ = false;
   UpdateDeviceEmulationState();
   return Response::OK();
 }
 
+RenderWidgetHostImpl* EmulationHandler::GetRenderWidgetHost() {
+  // TODO(dgozman): there should be a way to get main RenderWidgetHost from
+  // WebContents without RenderViewHost.

[nasko, 2015/03/31 14:43:36]

WebContentsImpl::GetMainFrame()->GetRenderWidgetHost()?

[dgozman, 2015/03/31 15:05:23]

So, do you think it's a property of frame? This class, for example, doesn't care
about frames. It just wants to send page-level IPC (handled in RenderWidget at
the moment). PageHandler just wants to grab a screenshot of the whole page, not
caring about frame either.

[dgozman, 2015/03/31 16:44:59]

Done.

+  return web_contents_ ?
+      static_cast<RenderViewHostImpl*>(web_contents_->GetRenderViewHost()) :
+      nullptr;
+}
+
 void EmulationHandler::UpdateTouchEventEmulationState() {
-  if (!host_)
+  if (!web_contents_)
     return;
   bool enabled = touch_emulation_enabled_ ||
       page_handler_->screencast_enabled();
   ui::GestureProviderConfigType config_type =
       TouchEmulationConfigurationToType(touch_emulation_configuration_);
-  host_->SetTouchEventEmulationEnabled(enabled, config_type);
-  WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
-      WebContents::FromRenderViewHost(host_));
-  if (web_contents)
-    web_contents->SetForceDisableOverscrollContent(enabled);
+  GetRenderWidgetHost()->SetTouchEventEmulationEnabled(enabled, config_type);
+  web_contents_->SetForceDisableOverscrollContent(enabled);
 }
 
 void EmulationHandler::UpdateDeviceEmulationState() {
-  if (!host_)
+  if (!web_contents_)
     return;
+  RenderWidgetHostImpl* widget_host = GetRenderWidgetHost();
   if (device_emulation_enabled_) {
-    host_->Send(new ViewMsg_EnableDeviceEmulation(
-        host_->GetRoutingID(), device_emulation_params_));
+    widget_host->Send(new ViewMsg_EnableDeviceEmulation(
+        widget_host->GetRoutingID(), device_emulation_params_));
   } else {
-    host_->Send(new ViewMsg_DisableDeviceEmulation(host_->GetRoutingID()));
+    widget_host->Send(new ViewMsg_DisableDeviceEmulation(
+        widget_host->GetRoutingID()));
   }
 }
 
 }  // namespace emulation
 }  // namespace devtools
 }  // namespace content