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 89 matching lines @@
   e->modifiers = modifiersWithButtons(modifiers, current_buttons);
   e->x = pos.x;
   e->y = pos.y;
   e->globalX = pos.x;
   e->globalY = pos.y;
   e->pointerType = blink::WebPointerProperties::PointerType::Mouse;
   e->timeStampSeconds = time_stamp;
   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")
 #ifndef __APPLE__
       || !strcmp(characters, "addSelectionKey")
 #endif
       ) {
     return WebInputEvent::ControlKey;
   } else if (!strcmp(characters, "shiftKey") ||
              !strcmp(characters, "rangeSelectionKey")) {
@@ skipping 365 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;
+  // 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) {
   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 171 matching lines @@
     const WebInputEvent& event) {
   last_event_timestamp_ = event.timeStampSeconds;
 
   if (WebPagePopup* popup = view_->pagePopup()) {
     if (!WebInputEvent::isKeyboardEventType(event.type))
       return popup->handleInputEvent(event);
   }
   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