DevTools: control touch emulation from the browser side only.

content/browser/devtools/renderer_overrides_handler.cc

 // Copyright (c) 2013 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/renderer_overrides_handler.h"
 
 #include <map>
 #include <string>
 
 #include "base/barrier_closure.h"
@@ skipping 56 matching lines @@
 static const char kJpeg[] = "jpeg";
 static int kDefaultScreenshotQuality = 80;
 static int kFrameRateThresholdMs = 100;
 static int kCaptureRetryLimit = 2;
 
 }  // namespace
 
 RendererOverridesHandler::RendererOverridesHandler()
     : has_last_compositor_frame_metadata_(false),
       capture_retry_count_(0),
+      touch_emulation_enabled_(false),
       color_picker_enabled_(false),
       last_cursor_x_(-1),
       last_cursor_y_(-1),
       weak_factory_(this) {
   RegisterCommandHandler(
       devtools::DOM::setFileInputFiles::kName,
       base::Bind(
           &RendererOverridesHandler::GrantPermissionsForSetFileInputFiles,
           base::Unretained(this)));
   RegisterCommandHandler(
@@ skipping 34 matching lines @@
       devtools::Page::navigateToHistoryEntry::kName,
       base::Bind(
           &RendererOverridesHandler::PageNavigateToHistoryEntry,
           base::Unretained(this)));
   RegisterCommandHandler(
       devtools::Page::captureScreenshot::kName,
       base::Bind(
           &RendererOverridesHandler::PageCaptureScreenshot,
           base::Unretained(this)));
   RegisterCommandHandler(
+      devtools::Page::setTouchEmulationEnabled::kName,
+      base::Bind(
+          &RendererOverridesHandler::PageSetTouchEmulationEnabled,
+          base::Unretained(this)));
+  RegisterCommandHandler(
       devtools::Page::canScreencast::kName,
       base::Bind(
           &RendererOverridesHandler::PageCanScreencast,
           base::Unretained(this)));
   RegisterCommandHandler(
       devtools::Page::startScreencast::kName,
       base::Bind(
           &RendererOverridesHandler::PageStartScreencast,
           base::Unretained(this)));
   RegisterCommandHandler(
@@ skipping 17 matching lines @@
           &RendererOverridesHandler::InputEmulateTouchFromMouseEvent,
           base::Unretained(this)));
   mouse_event_callback_ = base::Bind(
       &RendererOverridesHandler::HandleMouseEvent,
       base::Unretained(this));
 }
 
 RendererOverridesHandler::~RendererOverridesHandler() {}
 
 void RendererOverridesHandler::OnClientDetached() {
-  if (screencast_command_ && host_)
-    host_->SetTouchEventEmulationEnabled(false, false);
+  touch_emulation_enabled_ = false;
   screencast_command_ = NULL;
+  UpdateTouchEventEmulationState();
   SetColorPickerEnabled(false);
 }
 
 void RendererOverridesHandler::OnSwapCompositorFrame(
     const cc::CompositorFrameMetadata& frame_metadata) {
   last_compositor_frame_metadata_ = frame_metadata;
   has_last_compositor_frame_metadata_ = true;
 
   if (screencast_command_)
     InnerSwapCompositorFrame();
   if (color_picker_enabled_)
     UpdateColorPickerFrame();
 }
 
 void RendererOverridesHandler::OnVisibilityChanged(bool visible) {
   if (!screencast_command_)
     return;
   NotifyScreencastVisibility(visible);
 }
 
 void RendererOverridesHandler::SetRenderViewHost(
     RenderViewHostImpl* host) {
   host_ = host;
   if (!host)
     return;
-  if (screencast_command_)
-    host->SetTouchEventEmulationEnabled(true, true);
+  UpdateTouchEventEmulationState();
   if (color_picker_enabled_)
     host->AddMouseEventCallback(mouse_event_callback_);
 }
 
 void RendererOverridesHandler::ClearRenderViewHost() {
   if (host_)
     host_->RemoveMouseEventCallback(mouse_event_callback_);
   host_ = NULL;
   ResetColorPickerFrame();
 }
 
-bool RendererOverridesHandler::OnSetTouchEventEmulationEnabled() {
-  return screencast_command_.get() != NULL;
-}
-
 void RendererOverridesHandler::InnerSwapCompositorFrame() {
   if ((base::TimeTicks::Now() - last_frame_time_).InMilliseconds() <
           kFrameRateThresholdMs) {
     return;
   }
 
   if (!host_ || !host_->GetView())
     return;
 
   last_frame_time_ = base::TimeTicks::Now();
@@ skipping 103 matching lines @@
   GetContentClient()->browser()->ClearCookies(host_);
   return command->SuccessResponse(NULL);
 }
 
 
 // Page agent handlers  -------------------------------------------------------
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageDisable(
     scoped_refptr<DevToolsProtocol::Command> command) {
-  if (screencast_command_ && host_)
-    host_->SetTouchEventEmulationEnabled(false, false);
-  screencast_command_ = NULL;
+  OnClientDetached();
   return NULL;
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageHandleJavaScriptDialog(
     scoped_refptr<DevToolsProtocol::Command> command) {
   base::DictionaryValue* params = command->params();
   const char* paramAccept =
       devtools::Page::handleJavaScriptDialog::kParamAccept;
   bool accept = false;
@@ skipping 157 matching lines @@
       &base_64_data);
 
   base::DictionaryValue* response = new base::DictionaryValue();
   response->SetString(devtools::Page::screencastFrame::kParamData,
                       base_64_data);
 
   SendAsyncResponse(command->SuccessResponse(response));
 }
 
 scoped_refptr<DevToolsProtocol::Response>
+RendererOverridesHandler::PageSetTouchEmulationEnabled(
+    scoped_refptr<DevToolsProtocol::Command> command) {
+  base::DictionaryValue* params = command->params();
+  bool enabled = false;
+  if (!params || !params->GetBoolean(
+      devtools::Page::setTouchEmulationEnabled::kParamEnabled,
+      &enabled)) {
+    // Pass to renderer.
+    return NULL;
+  }
+
+  touch_emulation_enabled_ = enabled;
+  UpdateTouchEventEmulationState();
+
+  // Pass to renderer.
+  return NULL;
+}
+
+scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageCanScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   base::DictionaryValue* result = new base::DictionaryValue();
 #if defined(OS_ANDROID)
   result->SetBoolean(devtools::kResult, true);
 #else
   result->SetBoolean(devtools::kResult, false);
 #endif  // defined(OS_ANDROID)
   return command->SuccessResponse(result);
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageStartScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   screencast_command_ = command;
+  UpdateTouchEventEmulationState();
   if (!host_)
     return command->InternalErrorResponse("Could not connect to view");
-  host_->SetTouchEventEmulationEnabled(true, true);
   bool visible = !host_->is_hidden();
   NotifyScreencastVisibility(visible);
   if (visible) {
     if (has_last_compositor_frame_metadata_)
       InnerSwapCompositorFrame();
     else
       host_->Send(new ViewMsg_ForceRedraw(host_->GetRoutingID(), 0));
   }
   return command->SuccessResponse(NULL);
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageStopScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   last_frame_time_ = base::TimeTicks();
   screencast_command_ = NULL;
-  if (host_)
-    host_->SetTouchEventEmulationEnabled(false, false);
+  UpdateTouchEventEmulationState();
   return command->SuccessResponse(NULL);
 }
 
 void RendererOverridesHandler::ScreencastFrameCaptured(
     const std::string& format,
     int quality,
     const cc::CompositorFrameMetadata& metadata,
     bool success,
     const SkBitmap& bitmap) {
   if (!success) {
@@ skipping 659 matching lines @@
   if (!host_)
     return command->InternalErrorResponse("Could not connect to view");
 
   if (event->type == WebInputEvent::MouseWheel)
     host_->ForwardWheelEvent(wheel_event);
   else
     host_->ForwardMouseEvent(mouse_event);
   return command->SuccessResponse(NULL);
 }
 
+void RendererOverridesHandler::UpdateTouchEventEmulationState() {
+  if (!host_)
+    return;
+  bool enabled = touch_emulation_enabled_ || screencast_command_;
+  host_->SetTouchEventEmulationEnabled(enabled);
+  WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
+      WebContents::FromRenderViewHost(host_));
+  if (web_contents)
+    web_contents->SetForceDisableOverscrollContent(enabled);
+}
+
 }  // namespace content