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, true);
 }
 
 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, false);
 }
 
 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, bool continuous) {

[Mike West, 2016/03/17 16:19:38]

Nit: I'd prefer for this to be an enum so that it's clear at the callsite what
"true" or "false" means.

[dtapuska, 2016/03/17 18:05:51]

Done.

+  WebMouseWheelEvent wheel_event;
+  bool send_gestures = false;
+  InitMouseWheelEvent(args, continuous, &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;
+    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)

[Mike West, 2016/03/17 16:19:38]

Nit: {} around multi-line body.

[dtapuska, 2016/03/17 18:05:51]

Done.

+        begin_event.data.scrollBegin.deltaXHint =
+            begin_event.data.scrollBegin.deltaXHint > 0 ? 1 : -1;
+      if (begin_event.data.scrollBegin.deltaYHint)

[Mike West, 2016/03/17 16:19:38]

Nit: {} around multi-line body.

[dtapuska, 2016/03/17 18:05:51]

Done.

+        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;
+    }
+    WebGestureEvent update_event = begin_event;
+    update_event.type = WebInputEvent::GestureScrollUpdate;
+    memset(&update_event.data, 0, sizeof(update_event.data));

[Mike West, 2016/03/17 16:19:38]

Could we move this to a `clear()` method on WebGestureEvent or something
similar? I don't like seeing direct memory operations scattered throughout the
codebase.

[dtapuska, 2016/03/17 18:05:51]

I've just cloned the fields over manually and avoided the base object cloning.

+    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;
+
+    WebGestureEvent end_event = begin_event;
+    end_event.type = WebInputEvent::GestureScrollEnd;
+    memset(&end_event.data, 0, sizeof(end_event.data));
+    end_event.data.scrollEnd.deltaUnits =
+        begin_event.data.scrollBegin.deltaHintUnits;
+
+    if (force_layout_on_events_)
+      view_->updateAllLifecyclePhases();
+
+    HandleInputEventOnViewOrPopup(begin_event);
+
+    if (force_layout_on_events_)
+      view_->updateAllLifecyclePhases();
+    HandleInputEventOnViewOrPopup(update_event);
+
+    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 314 matching lines @@
       (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) {
+                                      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);
@@ skipping 189 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