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..393572482957e5cc3f4162a6fbb5fb366717c278 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"
@@ -115,6 +116,19 @@ void InitMouseEvent(WebInputEvent::Type t,
   e->clickCount = click_count;
 }
 
+void InitGestureEventFromMouseWheel(WebInputEvent::Type type,
+                                    double time_stamp,
+                                    const WebMouseWheelEvent& wheel_event,
+                                    WebGestureEvent* gesture_event) {
+  gesture_event->type = type;
+  gesture_event->sourceDevice = blink::WebGestureDeviceTouchpad;
+  gesture_event->x = wheel_event.x;
+  gesture_event->y = wheel_event.y;
+  gesture_event->globalX = wheel_event.globalX;
+  gesture_event->globalY = wheel_event.globalY;
+  gesture_event->timeStampSeconds = time_stamp;
+}
+
 int GetKeyModifier(const std::string& modifier_name) {
   const char* characters = modifier_name.c_str();
   if (!strcmp(characters, "ctrlKey")
@@ -500,8 +514,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 +530,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 +639,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 +660,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 +854,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 +921,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 +934,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 +1180,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 +1900,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 +1952,19 @@ 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;
+  // TODO(dtapuska): Gestures really should be sent by the MouseWheelEventQueue
+  // class in the browser. But since the event doesn't propogate up into
+  // the browser generate the events here. See crbug.com/596095.
+  bool send_gestures = false;
+  InitMouseWheelEvent(args, scroll_type, &wheel_event, &send_gestures);
+  if (HandleInputEventOnViewOrPopup(wheel_event) ==
+          WebInputEventResult::NotHandled &&
+      send_gestures) {
+    SendGesturesForMouseWheelEvent(wheel_event);
+  }
 }
 
 void EventSender::MouseMoveTo(gin::Arguments* args) {
@@ -2063,50 +2021,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 +2354,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 +2386,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 +2412,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 {
@@ -2684,4 +2604,61 @@ WebInputEventResult EventSender::HandleInputEventOnViewOrPopup(
   return view_->handleInputEvent(event);
 }
 
+void EventSender::SendGesturesForMouseWheelEvent(
+    const WebMouseWheelEvent wheel_event) {
+  WebGestureEvent begin_event;
+  InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollBegin,
+                                 GetCurrentEventTimeSec(), wheel_event,
+                                 &begin_event);
+  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;
+  InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollUpdate,
+                                 GetCurrentEventTimeSec(), wheel_event,
+                                 &update_event);
+  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;
+  InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollEnd,
+                                 GetCurrentEventTimeSec(), wheel_event,
+                                 &end_event);
+  end_event.data.scrollEnd.deltaUnits =
+      begin_event.data.scrollBegin.deltaHintUnits;
+
+  if (force_layout_on_events_)
+    view_->updateAllLifecyclePhases();
+  HandleInputEventOnViewOrPopup(end_event);
+}
+
 }  // namespace test_runner