Indicate whether a touch event will cause scrolling

content/browser/renderer_host/input/touch_emulator.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/renderer_host/input/touch_emulator.h"
 
 #include "content/browser/renderer_host/input/motion_event_web.h"
 #include "content/browser/renderer_host/input/web_input_event_util.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "content/grit/content_resources.h"
@@ skipping 11 matching lines @@
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 
 namespace content {
 
 namespace {
 
 ui::GestureProvider::Config GetGestureProviderConfig() {
   // TODO(dgozman): Use different configs to emulate mobile/desktop as
-  // requested by renderer.
+  // requested by renderer, crbug/425586.
   ui::GestureProvider::Config config = ui::DefaultGestureProviderConfig();
   config.gesture_begin_end_types_enabled = false;
   config.gesture_detector_config.swipe_enabled = false;
   config.gesture_detector_config.two_finger_tap_enabled = false;
   return config;
 }
 
 // Time between two consecutive mouse moves, during which second mouse move
 // is not converted to touch.
 const double kMouseMoveDropIntervalSeconds = 5.f / 1000;
@@ skipping 107 matching lines @@
     last_mouse_event_was_move_ = false;
   }
 
   if (mouse_event.type == WebInputEvent::MouseDown)
     mouse_pressed_ = true;
   else if (mouse_event.type == WebInputEvent::MouseUp)
     mouse_pressed_ = false;
 
   UpdateShiftPressed((mouse_event.modifiers & WebInputEvent::ShiftKey) != 0);
 
-  if (FillTouchEventAndPoint(mouse_event) &&
-      gesture_provider_.OnTouchEvent(MotionEventWeb(touch_event_))) {
-    ForwardTouchEventToClient();
+  if (mouse_event.type != WebInputEvent::MouseDown &&
+      mouse_event.type != WebInputEvent::MouseMove &&
+      mouse_event.type != WebInputEvent::MouseUp) {
+    return true;
   }
 
+  FillTouchEventAndPoint(mouse_event);
+  HandleEmulatedTouchEvent(touch_event_);
+
   // Do not pass mouse events to the renderer.
   return true;
 }
 
 bool TouchEmulator::HandleMouseWheelEvent(const WebMouseWheelEvent& event) {
   if (!enabled_)
     return false;
 
   // Send mouse wheel for easy scrolling when there is no active touch.
   return emulated_stream_active_sequence_count_ > 0;
@@ skipping 30 matching lines @@
   bool is_sequence_start = WebTouchEventTraits::IsTouchSequenceStart(event);
   // Do not allow middle-sequence event to pass through, if start was blocked.
   if (!native_stream_active_sequence_count_ && !is_sequence_start)
     return true;
 
   if (is_sequence_start)
     native_stream_active_sequence_count_++;
   return false;
 }
 
-void TouchEmulator::ForwardTouchEventToClient() {
+void TouchEmulator::HandleEmulatedTouchEvent(blink::WebTouchEvent event) {
+  auto result = gesture_provider_.OnTouchEvent(MotionEventWeb(event));
+  if (!result.succeeded)
+    return;
+
   const bool event_consumed = true;
   // Block emulated event when emulated native stream is active.
   if (native_stream_active_sequence_count_) {
     gesture_provider_.OnTouchEventAck(event_consumed);
     return;
   }
 
-  bool is_sequence_start =
-      WebTouchEventTraits::IsTouchSequenceStart(touch_event_);
+  bool is_sequence_start = WebTouchEventTraits::IsTouchSequenceStart(event);
   // Do not allow middle-sequence event to pass through, if start was blocked.
   if (!emulated_stream_active_sequence_count_ && !is_sequence_start) {
     gesture_provider_.OnTouchEventAck(event_consumed);
     return;
   }
 
   if (is_sequence_start)
     emulated_stream_active_sequence_count_++;
-  client_->ForwardEmulatedTouchEvent(touch_event_);
+
+  event.causesScrollingIfUncanceled = result.did_generate_scroll;
+  client_->ForwardEmulatedTouchEvent(event);
 }
 
 bool TouchEmulator::HandleTouchEventAck(
     const blink::WebTouchEvent& event, InputEventAckState ack_result) {
   bool is_sequence_end = WebTouchEventTraits::IsTouchSequenceEnd(event);
   if (emulated_stream_active_sequence_count_) {
     if (is_sequence_end)
       emulated_stream_active_sequence_count_--;
 
     const bool event_consumed = ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
@@ skipping 75 matching lines @@
 }
 
 void TouchEmulator::CancelTouch() {
   if (!emulated_stream_active_sequence_count_)
     return;
 
   WebTouchEventTraits::ResetTypeAndTouchStates(
       WebInputEvent::TouchCancel,
       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF(),
       &touch_event_);
-  if (gesture_provider_.GetCurrentDownEvent() &&
-      gesture_provider_.OnTouchEvent(MotionEventWeb(touch_event_)))
-    ForwardTouchEventToClient();
+  if (gesture_provider_.GetCurrentDownEvent())
+    HandleEmulatedTouchEvent(touch_event_);
 }
 
 void TouchEmulator::UpdateCursor() {
   if (!enabled_)
     client_->SetCursor(pointer_cursor_);
   else
     client_->SetCursor(InPinchGestureMode() ? pinch_cursor_ : touch_cursor_);
 }
 
 bool TouchEmulator::UpdateShiftPressed(bool shift_pressed) {
@@ skipping 44 matching lines @@
 
 void TouchEmulator::ScrollEnd(const WebGestureEvent& event) {
   WebGestureEvent scroll_event;
   scroll_event.timeStampSeconds = event.timeStampSeconds;
   scroll_event.modifiers = event.modifiers;
   scroll_event.sourceDevice = blink::WebGestureDeviceTouchscreen;
   scroll_event.type = WebInputEvent::GestureScrollEnd;
   client_->ForwardGestureEvent(scroll_event);
 }
 
-bool TouchEmulator::FillTouchEventAndPoint(const WebMouseEvent& mouse_event) {
-  if (mouse_event.type != WebInputEvent::MouseDown &&
-      mouse_event.type != WebInputEvent::MouseMove &&
-      mouse_event.type != WebInputEvent::MouseUp) {
-    return false;
-  }
-
+void TouchEmulator::FillTouchEventAndPoint(const WebMouseEvent& mouse_event) {
   WebInputEvent::Type eventType;
   switch (mouse_event.type) {
     case WebInputEvent::MouseDown:
       eventType = WebInputEvent::TouchStart;
       break;
     case WebInputEvent::MouseMove:
       eventType = WebInputEvent::TouchMove;
       break;
     case WebInputEvent::MouseUp:
       eventType = WebInputEvent::TouchEnd;
       break;
     default:
       eventType = WebInputEvent::Undefined;
-      NOTREACHED();
+      NOTREACHED() << "Invalid event for touch emulation: " << mouse_event.type;
   }
   touch_event_.touchesLength = 1;
   touch_event_.modifiers = mouse_event.modifiers;
   WebTouchEventTraits::ResetTypeAndTouchStates(
       eventType, mouse_event.timeStampSeconds, &touch_event_);
 
   WebTouchPoint& point = touch_event_.touches[0];
   point.id = 0;
   point.radiusX = 0.5f * cursor_size_.width();
   point.radiusY = 0.5f * cursor_size_.height();
   point.force = 1.f;
   point.rotationAngle = 0.f;
   point.position.x = mouse_event.x;
   point.screenPosition.x = mouse_event.globalX;
   point.position.y = mouse_event.y;
   point.screenPosition.y = mouse_event.globalY;
-
-  return true;
 }
 
 bool TouchEmulator::InPinchGestureMode() const {
   return shift_pressed_;
 }
 
 }  // namespace content