[DevTools] Cleanup after moving from Page to Emulation.

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/string_number_conversions.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/devtools/protocol/frame_recorder.h"
-#include "content/browser/geolocation/geolocation_service_context.h"
 #include "content/browser/renderer_host/render_view_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/storage_partition.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/referrer.h"
-#include "content/public/common/url_constants.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"
 #include "url/gurl.h"
 
 namespace content {
 namespace devtools {
 namespace page {
 
 namespace {
 
 static const char kPng[] = "png";
 static const char kJpeg[] = "jpeg";
 static int kDefaultScreenshotQuality = 80;
 static int kFrameRetryDelayMs = 100;
 static int kCaptureRetryLimit = 2;
 static int kMaxScreencastFramesInFlight = 2;
 
-ui::GestureProviderConfigType TouchEmulationConfigurationToType(
-    const std::string& protocol_value) {
-  ui::GestureProviderConfigType result =
-      ui::GestureProviderConfigType::CURRENT_PLATFORM;
-  if (protocol_value == "mobile") {
-    result = ui::GestureProviderConfigType::GENERIC_MOBILE;
-  }
-  if (protocol_value == "desktop") {
-    result = ui::GestureProviderConfigType::GENERIC_DESKTOP;
-  }
-  return result;
-}
-
 std::string EncodeScreencastFrame(const SkBitmap& bitmap,
                                   const std::string& format,
                                   int quality) {
   std::vector<unsigned char> data;
   SkAutoLockPixels lock_image(bitmap);
   bool encoded;
   if (format == kPng) {
     encoded = gfx::PNGCodec::Encode(
         reinterpret_cast<unsigned char*>(bitmap.getAddr32(0, 0)),
         gfx::PNGCodec::FORMAT_SkBitmap,
@@ skipping 22 matching lines @@
 
   return base_64_data;
 }
 
 }  // namespace
 
 typedef DevToolsProtocolClient::Response Response;
 
 PageHandler::PageHandler()
     : enabled_(false),
-      touch_emulation_enabled_(false),
-      device_emulation_enabled_(false),
       screencast_enabled_(false),
       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)))),
       frame_recorder_(new FrameRecorder()),
       host_(nullptr),
       screencast_listener_(nullptr),
       weak_factory_(this) {
 }
 
 PageHandler::~PageHandler() {
 }
 
 void PageHandler::SetRenderViewHost(RenderViewHostImpl* host) {
   if (host_ == host)
     return;
 
   color_picker_->SetRenderViewHost(host);
   frame_recorder_->SetRenderViewHost(host);
   host_ = host;
-  UpdateTouchEventEmulationState();
-  UpdateDeviceEmulationState();
 }
 
 void PageHandler::SetClient(scoped_ptr<Client> client) {
   client_.swap(client);
 }
 
 void PageHandler::Detached() {
   Disable();
 }
 
@@ skipping 32 matching lines @@
   screencast_listener_ = listener;
 }
 
 Response PageHandler::Enable() {
   enabled_ = true;
   return Response::FallThrough();
 }
 
 Response PageHandler::Disable() {
   enabled_ = false;
-  touch_emulation_enabled_ = false;
   screencast_enabled_ = false;
-  device_emulation_enabled_ = false;
-  UpdateTouchEventEmulationState();
-  UpdateDeviceEmulationState();
   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_)
@@ skipping 62 matching lines @@
   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::SetGeolocationOverride(double* latitude,
-                                             double* longitude,
-                                             double* accuracy) {
-  if (!host_)
-    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();
-  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 PageHandler::ClearGeolocationOverride() {
-  if (!host_)
-    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();
-  geolocation_context->ClearOverride();
-  return Response::OK();
-}
-
-Response PageHandler::SetTouchEmulationEnabled(
-    bool enabled, const std::string* configuration) {
-  touch_emulation_enabled_ = enabled;
-  touch_emulation_configuration_ =
-      configuration ? *configuration : std::string();
-  UpdateTouchEventEmulationState();
-  return Response::FallThrough();
-}
-
 Response PageHandler::CaptureScreenshot(DevToolsCommandId command_id) {
   if (!host_ || !host_->GetView())
     return Response::InternalError("Could not connect to view");
 
   host_->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::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 defined(DEBUG_DEVTOOLS)
-      *result &= !web_contents->GetVisibleURL().SchemeIs(kChromeDevToolsScheme);
-#endif  // defined(DEBUG_DEVTOOLS)
-    } else {
-      *result = true;
-    }
-  } else {
-    *result = true;
-  }
-#endif  // defined(OS_ANDROID)
-  return Response::OK();
-}
-
-Response PageHandler::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_)
-    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");
-
-  if (optional_scale && (*optional_scale <= 0 || *optional_scale > max_scale)) {
-    return Response::InvalidParams(
-        "scale must be positive, not greater than " +
-        base::IntToString(max_scale));
-  }
-
-  blink::WebDeviceEmulationParams params;
-  params.screenPosition = mobile ? blink::WebDeviceEmulationParams::Mobile :
-      blink::WebDeviceEmulationParams::Desktop;
-  params.deviceScaleFactor = device_scale_factor;
-  params.viewSize = blink::WebSize(width, height);
-  params.fitToView = fit_window;
-  params.scale = optional_scale ? *optional_scale : 1;
-  params.offset = blink::WebFloatPoint(
-      optional_offset_x ? *optional_offset_x : 0.f,
-      optional_offset_y ? *optional_offset_y : 0.f);
-
-  if (device_emulation_enabled_ && params == device_emulation_params_)
-    return Response::OK();
-
-  device_emulation_enabled_ = true;
-  device_emulation_params_ = params;
-  UpdateDeviceEmulationState();
-  return Response::OK();
-}
-
-Response PageHandler::ClearDeviceMetricsOverride() {
-  if (!device_emulation_enabled_)
-    return Response::OK();
-
-  device_emulation_enabled_ = false;
-  UpdateDeviceEmulationState();
-  return Response::OK();
-}
-
 Response PageHandler::StartScreencast(const std::string* format,
                                       const int* quality,
                                       const int* max_width,
                                       const int* max_height) {
   if (!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;
 
-  UpdateTouchEventEmulationState();
   bool visible = !host_->is_hidden();
   NotifyScreencastVisibility(visible);
   if (visible) {
     if (has_compositor_frame_metadata_)
       InnerSwapCompositorFrame();
     else
       host_->Send(new ViewMsg_ForceRedraw(host_->GetRoutingID(), 0));
   }
   if (screencast_listener_)
     screencast_listener_->ScreencastEnabledChanged();
   return Response::FallThrough();
 }
 
 Response PageHandler::StopScreencast() {
   screencast_enabled_ = false;
-  UpdateTouchEventEmulationState();
   if (screencast_listener_)
     screencast_listener_->ScreencastEnabledChanged();
   return Response::FallThrough();
 }
 
 Response PageHandler::StartRecordingFrames(int max_frame_count) {
   return frame_recorder_->StartRecordingFrames(max_frame_count);
 }
 
 Response PageHandler::StopRecordingFrames(DevToolsCommandId command_id) {
@@ skipping 39 matching lines @@
 }
 
 Response PageHandler::SetColorPickerEnabled(bool enabled) {
   if (!host_)
     return Response::InternalError("Could not connect to view");
 
   color_picker_->SetEnabled(enabled);
   return Response::OK();
 }
 
-void PageHandler::UpdateTouchEventEmulationState() {
-  if (!host_)
-    return;
-  bool enabled = touch_emulation_enabled_ || 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);
-}
-
-void PageHandler::UpdateDeviceEmulationState() {
-  if (!host_)
-    return;
-  if (device_emulation_enabled_) {
-    host_->Send(new ViewMsg_EnableDeviceEmulation(
-        host_->GetRoutingID(), device_emulation_params_));
-  } else {
-    host_->Send(new ViewMsg_DisableDeviceEmulation(host_->GetRoutingID()));
-  }
-}
-
 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 129 matching lines @@
 
 void PageHandler::OnFramesRecorded(
     DevToolsCommandId command_id,
     scoped_refptr<StopRecordingFramesResponse> response_data) {
   client_->SendStopRecordingFramesResponse(command_id, response_data);
 }
 
 }  // namespace page
 }  // namespace devtools
 }  // namespace content