Send wheel gestures from event sender.

components/test_runner/event_sender.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 "components/test_runner/event_sender.h"
 
 #include <stddef.h>
 
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "components/test_runner/mock_spell_check.h"
 #include "components/test_runner/test_interfaces.h"
 #include "components/test_runner/web_test_delegate.h"
@@ skipping 474 matching lines @@
   void GestureScrollFirstPoint(int x, int y);
   void TouchStart();
   void TouchMove();
   void TouchMoveCausingScrollIfUncanceled();
   void TouchCancel();
   void TouchEnd();
   void LeapForward(int milliseconds);
   double LastEventTimestamp();
   void BeginDragWithFiles(const std::vector<std::string>& files);
   void AddTouchPoint(double x, double y, gin::Arguments* args);
-  void MouseDragBegin();
-  void MouseDragEnd();
   void GestureScrollBegin(gin::Arguments* args);
   void GestureScrollEnd(gin::Arguments* args);
   void GestureScrollUpdate(gin::Arguments* args);
   void GesturePinchBegin(gin::Arguments* args);
   void GesturePinchEnd(gin::Arguments* args);
   void GesturePinchUpdate(gin::Arguments* args);
   void GestureTap(gin::Arguments* args);
   void GestureTapDown(gin::Arguments* args);
   void GestureShowPress(gin::Arguments* args);
   void GestureTapCancel(gin::Arguments* args);
   void GestureLongPress(gin::Arguments* args);
   void GestureLongTap(gin::Arguments* args);
   void GestureTwoFingerTap(gin::Arguments* args);
   void ContinuousMouseScrollBy(gin::Arguments* args);
   void MouseMoveTo(gin::Arguments* args);
   void MouseLeave();
-  void TrackpadScrollBegin();
-  void TrackpadScroll(gin::Arguments* args);
-  void TrackpadScrollEnd();
   void MouseScrollBy(gin::Arguments* args);
   void ScheduleAsynchronousClick(gin::Arguments* args);
   void ScheduleAsynchronousKeyDown(gin::Arguments* args);
   void MouseDown(gin::Arguments* args);
   void MouseUp(gin::Arguments* args);
   void SetMouseButtonState(gin::Arguments* args);
   void KeyDown(gin::Arguments* args);
 
   // Binding properties:
   bool ForceLayoutOnEvents() const;
@@ skipping 89 matching lines @@
       .SetMethod("touchStart", &EventSenderBindings::TouchStart)
       .SetMethod("touchMove", &EventSenderBindings::TouchMove)
       .SetMethod("touchMoveCausingScrollIfUncanceled",
                  &EventSenderBindings::TouchMoveCausingScrollIfUncanceled)
       .SetMethod("touchCancel", &EventSenderBindings::TouchCancel)
       .SetMethod("touchEnd", &EventSenderBindings::TouchEnd)
       .SetMethod("leapForward", &EventSenderBindings::LeapForward)
       .SetMethod("lastEventTimestamp", &EventSenderBindings::LastEventTimestamp)
       .SetMethod("beginDragWithFiles", &EventSenderBindings::BeginDragWithFiles)
       .SetMethod("addTouchPoint", &EventSenderBindings::AddTouchPoint)
-      .SetMethod("mouseDragBegin", &EventSenderBindings::MouseDragBegin)
-      .SetMethod("mouseDragEnd", &EventSenderBindings::MouseDragEnd)
       .SetMethod("gestureScrollBegin", &EventSenderBindings::GestureScrollBegin)
       .SetMethod("gestureScrollEnd", &EventSenderBindings::GestureScrollEnd)
       .SetMethod("gestureScrollUpdate",
                  &EventSenderBindings::GestureScrollUpdate)
       .SetMethod("gesturePinchBegin", &EventSenderBindings::GesturePinchBegin)
       .SetMethod("gesturePinchEnd", &EventSenderBindings::GesturePinchEnd)
       .SetMethod("gesturePinchUpdate", &EventSenderBindings::GesturePinchUpdate)
       .SetMethod("gestureTap", &EventSenderBindings::GestureTap)
       .SetMethod("gestureTapDown", &EventSenderBindings::GestureTapDown)
       .SetMethod("gestureShowPress", &EventSenderBindings::GestureShowPress)
       .SetMethod("gestureTapCancel", &EventSenderBindings::GestureTapCancel)
       .SetMethod("gestureLongPress", &EventSenderBindings::GestureLongPress)
       .SetMethod("gestureLongTap", &EventSenderBindings::GestureLongTap)
       .SetMethod("gestureTwoFingerTap",
                  &EventSenderBindings::GestureTwoFingerTap)
       .SetMethod("continuousMouseScrollBy",
                  &EventSenderBindings::ContinuousMouseScrollBy)
       .SetMethod("keyDown", &EventSenderBindings::KeyDown)
       .SetMethod("mouseDown", &EventSenderBindings::MouseDown)
       .SetMethod("mouseMoveTo", &EventSenderBindings::MouseMoveTo)
       .SetMethod("mouseLeave", &EventSenderBindings::MouseLeave)
-      .SetMethod("trackpadScrollBegin",
-                 &EventSenderBindings::TrackpadScrollBegin)
-      .SetMethod("trackpadScroll", &EventSenderBindings::TrackpadScroll)
-      .SetMethod("trackpadScrollEnd", &EventSenderBindings::TrackpadScrollEnd)
       .SetMethod("mouseScrollBy", &EventSenderBindings::MouseScrollBy)
       .SetMethod("mouseUp", &EventSenderBindings::MouseUp)
       .SetMethod("setMouseButtonState",
                  &EventSenderBindings::SetMouseButtonState)
       .SetMethod("scheduleAsynchronousClick",
                  &EventSenderBindings::ScheduleAsynchronousClick)
       .SetMethod("scheduleAsynchronousKeyDown",
                  &EventSenderBindings::ScheduleAsynchronousKeyDown)
       .SetProperty("forceLayoutOnEvents",
                    &EventSenderBindings::ForceLayoutOnEvents,
@@ skipping 174 matching lines @@
     sender_->BeginDragWithFiles(files);
 }
 
 void EventSenderBindings::AddTouchPoint(double x,
                                         double y,
                                         gin::Arguments* args) {
   if (sender_)
     sender_->AddTouchPoint(static_cast<float>(x), static_cast<float>(y), args);
 }
 
-void EventSenderBindings::MouseDragBegin() {
-  if (sender_)
-    sender_->MouseDragBegin();
-}
-
-void EventSenderBindings::MouseDragEnd() {
-  if (sender_)
-    sender_->MouseDragEnd();
-}
-
 void EventSenderBindings::GestureScrollBegin(gin::Arguments* args) {
   if (sender_)
     sender_->GestureScrollBegin(args);
 }
 
 void EventSenderBindings::GestureScrollEnd(gin::Arguments* args) {
   if (sender_)
     sender_->GestureScrollEnd(args);
 }
 
@@ skipping 47 matching lines @@
     sender_->GestureLongTap(args);
 }
 
 void EventSenderBindings::GestureTwoFingerTap(gin::Arguments* args) {
   if (sender_)
     sender_->GestureTwoFingerTap(args);
 }
 
 void EventSenderBindings::ContinuousMouseScrollBy(gin::Arguments* args) {
   if (sender_)
-    sender_->ContinuousMouseScrollBy(args);
+    sender_->MouseScrollBy(args, EventSender::MouseScrollType::PIXEL);
 }
 
 void EventSenderBindings::MouseMoveTo(gin::Arguments* args) {
   if (sender_)
     sender_->MouseMoveTo(args);
 }
 
 void EventSenderBindings::MouseLeave() {
   if (sender_)
     sender_->MouseLeave();
 }
 
-void EventSenderBindings::TrackpadScrollBegin() {
-  if (sender_)
-    sender_->TrackpadScrollBegin();
-}
-
-void EventSenderBindings::TrackpadScroll(gin::Arguments* args) {
-  if (sender_)
-    sender_->TrackpadScroll(args);
-}
-
-void EventSenderBindings::TrackpadScrollEnd() {
-  if (sender_)
-    sender_->TrackpadScrollEnd();
-}
-
 void EventSenderBindings::MouseScrollBy(gin::Arguments* args) {
   if (sender_)
-    sender_->MouseScrollBy(args);
+    sender_->MouseScrollBy(args, EventSender::MouseScrollType::TICK);
 }
 
 void EventSenderBindings::ScheduleAsynchronousClick(gin::Arguments* args) {
   if (!sender_)
     return;
 
   int button_number = 0;
   int modifiers = 0;
   if (!args->PeekNext().IsEmpty()) {
     args->GetNext(&button_number);
@@ skipping 223 matching lines @@
       wm_char_(0),
       wm_dead_char_(0),
       wm_sys_key_down_(0),
       wm_sys_key_up_(0),
       wm_sys_char_(0),
       wm_sys_dead_char_(0),
 #endif
       interfaces_(interfaces),
       delegate_(NULL),
       view_(NULL),
+      send_wheel_gestures_(false),
       force_layout_on_events_(false),
       is_drag_mode_(true),
       touch_modifiers_(0),
       touch_cancelable_(true),
       replaying_saved_events_(false),
       current_drag_effects_allowed_(blink::WebDragOperationNone),
       last_click_time_sec_(0),
       current_drag_effect_(blink::WebDragOperationNone),
       time_offset_ms_(0),
       click_count_(0),
@@ skipping 699 matching lines @@
   InitPointerProperties(args, &touch_point, &touch_point.radiusX,
                         &touch_point.radiusY);
 
   // Set the touch point pressure to zero if it was not set by the caller
   if (std::isnan(touch_point.force))
       touch_point.force = 0.0;
 
   touch_points_.push_back(touch_point);
 }
 
-void EventSender::MouseDragBegin() {
-  WebMouseWheelEvent event;
-  InitMouseEvent(WebInputEvent::MouseWheel,
-                 WebMouseEvent::ButtonNone,
-                 0,
-                 last_mouse_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count_,
-                 0,
-                 &event);
-  event.phase = WebMouseWheelEvent::PhaseBegan;
-  event.hasPreciseScrollingDeltas = true;
-  HandleInputEventOnViewOrPopup(event);
-}
-
-void EventSender::MouseDragEnd() {
-  WebMouseWheelEvent event;
-  InitMouseEvent(WebInputEvent::MouseWheel,
-                 WebMouseEvent::ButtonNone,
-                 0,
-                 last_mouse_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count_,
-                 0,
-                 &event);
-  event.phase = WebMouseWheelEvent::PhaseEnded;
-  event.hasPreciseScrollingDeltas = true;
-  HandleInputEventOnViewOrPopup(event);
-}
-
 void EventSender::GestureScrollBegin(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureScrollBegin, args);
 }
 
 void EventSender::GestureScrollEnd(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureScrollEnd, args);
 }
 
 void EventSender::GestureScrollUpdate(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureScrollUpdate, args);
@@ skipping 32 matching lines @@
 }
 
 void EventSender::GestureLongTap(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureLongTap, args);
 }
 
 void EventSender::GestureTwoFingerTap(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureTwoFingerTap, args);
 }
 
-void EventSender::ContinuousMouseScrollBy(gin::Arguments* args) {
-  WebMouseWheelEvent event;
-  InitMouseWheelEvent(args, true, &event);
-  HandleInputEventOnViewOrPopup(event);
+void EventSender::MouseScrollBy(gin::Arguments* args,
+                                MouseScrollType scroll_type) {
+  WebMouseWheelEvent wheel_event;
+  bool send_gestures = false;
+  InitMouseWheelEvent(args, scroll_type, &wheel_event, &send_gestures);
+  if (HandleInputEventOnViewOrPopup(wheel_event) ==
+          WebInputEventResult::NotHandled &&
+      send_gestures) {
+    WebGestureEvent begin_event;
+    begin_event.type = WebInputEvent::GestureScrollBegin;
+    begin_event.sourceDevice = blink::WebGestureDeviceTouchpad;

[Rick Byers, 2016/03/18 15:36:25]

Generally our approach in eventSender is to generate only the events asked for
by the test (leaving it to the test to define exactly what the event stream
should look like).  But given the conditional nature, I agree this is the right
short term choice.  Longer term most tests should probably be migrated to use
browser-level synthetic input or (when we really want a blink input-handling
unit test) the test should have to explicitly request the wheel and gesture
events separately.

Can you please file a bug to track that cleanup and add a TODO here referencing
it?  In fact, it would probably be a little nicer if you put all the synthetic
wheel generation logic into it's own function (since the primary purpose of this
function is still just sending a wheel event).

You could probably also make this a little less verbose with a helper that
creates a WebGestureEvent from a WebMouseWheelEvent with the common bits, but
that's not a big deal - up to you.

[dtapuska, 2016/03/18 17:04:43]

Done.

+    begin_event.x = wheel_event.x;
+    begin_event.y = wheel_event.y;
+    begin_event.globalX = wheel_event.globalX;
+    begin_event.globalY = wheel_event.globalY;
+    begin_event.timeStampSeconds = GetCurrentEventTimeSec();
+    begin_event.data.scrollBegin.deltaXHint = wheel_event.deltaX;
+    begin_event.data.scrollBegin.deltaYHint = wheel_event.deltaY;
+    if (wheel_event.scrollByPage) {
+      begin_event.data.scrollBegin.deltaHintUnits =
+          blink::WebGestureEvent::Page;
+      if (begin_event.data.scrollBegin.deltaXHint) {
+        begin_event.data.scrollBegin.deltaXHint =
+            begin_event.data.scrollBegin.deltaXHint > 0 ? 1 : -1;
+      }
+      if (begin_event.data.scrollBegin.deltaYHint) {
+        begin_event.data.scrollBegin.deltaYHint =
+            begin_event.data.scrollBegin.deltaYHint > 0 ? 1 : -1;
+      }
+    } else {
+      begin_event.data.scrollBegin.deltaHintUnits =
+          wheel_event.hasPreciseScrollingDeltas
+              ? blink::WebGestureEvent::PrecisePixels
+              : blink::WebGestureEvent::Pixels;
+    }
+
+    if (force_layout_on_events_)
+      view_->updateAllLifecyclePhases();
+
+    HandleInputEventOnViewOrPopup(begin_event);
+
+    WebGestureEvent update_event;
+    update_event.type = WebInputEvent::GestureScrollUpdate;
+    update_event.sourceDevice = blink::WebGestureDeviceTouchpad;
+    update_event.x = wheel_event.x;
+    update_event.y = wheel_event.y;
+    update_event.globalX = wheel_event.globalX;
+    update_event.globalY = wheel_event.globalY;
+    update_event.timeStampSeconds = GetCurrentEventTimeSec();
+    update_event.data.scrollUpdate.deltaX =
+        begin_event.data.scrollBegin.deltaXHint;
+    update_event.data.scrollUpdate.deltaY =
+        begin_event.data.scrollBegin.deltaYHint;
+    update_event.data.scrollUpdate.deltaUnits =
+        begin_event.data.scrollBegin.deltaHintUnits;
+
+    if (force_layout_on_events_)
+      view_->updateAllLifecyclePhases();
+    HandleInputEventOnViewOrPopup(update_event);
+
+    WebGestureEvent end_event;
+    end_event.type = WebInputEvent::GestureScrollEnd;
+    end_event.sourceDevice = blink::WebGestureDeviceTouchpad;
+    end_event.x = wheel_event.x;
+    end_event.y = wheel_event.y;
+    end_event.globalX = wheel_event.globalX;
+    end_event.globalY = wheel_event.globalY;
+    end_event.timeStampSeconds = GetCurrentEventTimeSec();
+    end_event.data.scrollEnd.deltaUnits =
+        begin_event.data.scrollBegin.deltaHintUnits;
+
+    if (force_layout_on_events_)
+      view_->updateAllLifecyclePhases();
+    HandleInputEventOnViewOrPopup(end_event);
+  }
 }
 
 void EventSender::MouseMoveTo(gin::Arguments* args) {
   if (force_layout_on_events_)
     view_->updateAllLifecyclePhases();
 
   double x;
   double y;
   if (!args->GetNext(&x) || !args->GetNext(&y)) {
     args->ThrowError();
@@ skipping 36 matching lines @@
                  0,
                  last_mouse_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  0,
                  &event);
   HandleInputEventOnViewOrPopup(event);
 }
 
 
-void EventSender::TrackpadScrollBegin() {
-  WebMouseWheelEvent event;
-  InitMouseEvent(WebInputEvent::MouseWheel,
-                 WebMouseEvent::ButtonNone,
-                 0,
-                 last_mouse_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count_,
-                 0,
-                 &event);
-  event.phase = blink::WebMouseWheelEvent::PhaseBegan;
-  event.hasPreciseScrollingDeltas = true;
-  HandleInputEventOnViewOrPopup(event);
-}
-
-void EventSender::TrackpadScroll(gin::Arguments* args) {
-  WebMouseWheelEvent event;
-  InitMouseWheelEvent(args, true, &event);
-  event.phase = blink::WebMouseWheelEvent::PhaseChanged;
-  event.hasPreciseScrollingDeltas = true;
-  HandleInputEventOnViewOrPopup(event);
-}
-
-void EventSender::TrackpadScrollEnd() {
-  WebMouseWheelEvent event;
-  InitMouseEvent(WebInputEvent::MouseWheel,
-                 WebMouseEvent::ButtonNone,
-                 0,
-                 last_mouse_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count_,
-                 0,
-                 &event);
-  event.phase = WebMouseWheelEvent::PhaseEnded;
-  event.hasPreciseScrollingDeltas = true;
-  HandleInputEventOnViewOrPopup(event);
-}
-
-void EventSender::MouseScrollBy(gin::Arguments* args) {
-  WebMouseWheelEvent event;
-  InitMouseWheelEvent(args, false, &event);
-  HandleInputEventOnViewOrPopup(event);
-}
-
 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
   delegate_->PostTask(new MouseDownTask(this, button_number, modifiers));
   delegate_->PostTask(new MouseUpTask(this, button_number, modifiers));
 }
 
 void EventSender::ScheduleAsynchronousKeyDown(const std::string& code_str,
                                               int modifiers,
                                               KeyLocationCode location) {
   delegate_->PostTask(new KeyDownTask(this, code_str, modifiers, location));
 }
@@ skipping 313 matching lines @@
       (!OutsideMultiClickRadius(last_mouse_pos_, last_click_pos_)) &&
       (button_type == last_button_type_)) {
     ++click_count_;
   } else {
     click_count_ = 1;
     last_button_type_ = button_type;
   }
 }
 
 void EventSender::InitMouseWheelEvent(gin::Arguments* args,
-                                      bool continuous,
-                                      WebMouseWheelEvent* event) {
+                                      MouseScrollType scroll_type,
+                                      WebMouseWheelEvent* event,
+                                      bool* send_gestures) {
   // Force a layout here just to make sure every position has been
   // determined before we send events (as well as all the other methods
   // that send an event do).
   if (force_layout_on_events_)
     view_->updateAllLifecyclePhases();
 
   double horizontal;
   if (!args->GetNext(&horizontal)) {
     args->ThrowError();
     return;
   }
   double vertical;
   if (!args->GetNext(&vertical)) {
     args->ThrowError();
     return;
   }
 
   bool paged = false;
   bool has_precise_scrolling_deltas = false;
   int modifiers = 0;
   bool can_scroll = true;
   if (!args->PeekNext().IsEmpty()) {
     args->GetNext(&paged);
     if (!args->PeekNext().IsEmpty()) {
       args->GetNext(&has_precise_scrolling_deltas);
       if (!args->PeekNext().IsEmpty()) {
         v8::Local<v8::Value> value;
         args->GetNext(&value);
         modifiers = GetKeyModifiersFromV8(args->isolate(), value);
-        if (!args->PeekNext().IsEmpty())
+        if (!args->PeekNext().IsEmpty()) {
           args->GetNext(&can_scroll);
+        }
       }
     }
   }
+  if (can_scroll && send_wheel_gestures_) {
+    can_scroll = false;
+    *send_gestures = true;
+  }
 
   InitMouseEvent(WebInputEvent::MouseWheel,
                  pressed_button_,
                  current_buttons_,
                  last_mouse_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  modifiers,
                  event);
   event->wheelTicksX = static_cast<float>(horizontal);
   event->wheelTicksY = static_cast<float>(vertical);
   event->deltaX = event->wheelTicksX;
   event->deltaY = event->wheelTicksY;
   event->scrollByPage = paged;
   event->hasPreciseScrollingDeltas = has_precise_scrolling_deltas;
   event->canScroll = can_scroll;
-  if (continuous) {
+  if (scroll_type == MouseScrollType::PIXEL) {
     event->wheelTicksX /= kScrollbarPixelsPerTick;
     event->wheelTicksY /= kScrollbarPixelsPerTick;
   } else {
     event->deltaX *= kScrollbarPixelsPerTick;
     event->deltaY *= kScrollbarPixelsPerTick;
   }
 }
 
 // Radius fields radius_x and radius_y should eventually be moved to
 // WebPointerProperties.
@@ skipping 172 matching lines @@
   last_event_timestamp_ = event.timeStampSeconds;
 
   if (WebPagePopup* popup = view_->pagePopup()) {
     if (!WebInputEvent::isKeyboardEventType(event.type))
       return popup->handleInputEvent(event);
   }
   return view_->handleInputEvent(event);
 }
 
 }  // namespace test_runner