Send wheel gestures from event sender.

components/test_runner/event_sender.cc

Index: components/test_runner/event_sender.cc
diff --git a/components/test_runner/event_sender.cc b/components/test_runner/event_sender.cc
index 359aa00257dc96f993a983ed46be26b639e4b887..bd6cb6e5c60c11cd3adaea494f7fc965d93bd6d7 100644
--- a/components/test_runner/event_sender.cc
+++ b/components/test_runner/event_sender.cc
@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
@@ -500,8 +501,6 @@ class EventSenderBindings : public gin::Wrappable<EventSenderBindings> {
   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);
@@ -518,9 +517,6 @@ class EventSenderBindings : public gin::Wrappable<EventSenderBindings> {
   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);
@@ -630,8 +626,6 @@ EventSenderBindings::GetObjectTemplateBuilder(v8::Isolate* isolate) {
       .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",
@@ -653,10 +647,6 @@ EventSenderBindings::GetObjectTemplateBuilder(v8::Isolate* isolate) {
       .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",
@@ -851,16 +841,6 @@ void EventSenderBindings::AddTouchPoint(double x,
     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);
@@ -928,7 +908,7 @@ void EventSenderBindings::GestureTwoFingerTap(gin::Arguments* args) {
 
 void EventSenderBindings::ContinuousMouseScrollBy(gin::Arguments* args) {
   if (sender_)
-    sender_->ContinuousMouseScrollBy(args);
+    sender_->MouseScrollBy(args, EventSender::MouseScrollType::PIXEL);
 }
 
 void EventSenderBindings::MouseMoveTo(gin::Arguments* args) {
@@ -941,24 +921,9 @@ void EventSenderBindings::MouseLeave() {
     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) {
@@ -1202,6 +1167,7 @@ EventSender::EventSender(TestInterfaces* interfaces)
       interfaces_(interfaces),
       delegate_(NULL),
       view_(NULL),
+      send_wheel_gestures_(false),
       force_layout_on_events_(false),
       is_drag_mode_(true),
       touch_modifiers_(0),
@@ -1921,36 +1887,6 @@ void EventSender::AddTouchPoint(float x, float y, gin::Arguments* args) {
   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);
 }
@@ -2003,10 +1939,81 @@ 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) {
@@ -2063,50 +2070,6 @@ void EventSender::MouseLeave() {
 }
 
 
-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));
@@ -2440,8 +2403,9 @@ void EventSender::UpdateClickCountForButton(
 }
 
 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).
@@ -2471,11 +2435,16 @@ void EventSender::InitMouseWheelEvent(gin::Arguments* args,
         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_,
@@ -2492,7 +2461,7 @@ void EventSender::InitMouseWheelEvent(gin::Arguments* args,
   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 {