Enable sending gesture events from layout tests

content/shell/renderer/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 "content/shell/renderer/test_runner/event_sender.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/common/page_zoom.h"
@@ skipping 378 matching lines @@
   void TouchCancel();
   void TouchEnd();
   void LeapForward(int milliseconds);
   void BeginDragWithFiles(const std::vector<std::string>& files);
   void AddTouchPoint(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 TrackpadScrollBegin();
@@ skipping 110 matching lines @@
       .SetMethod("touchEnd", &EventSenderBindings::TouchEnd)
       .SetMethod("leapForward", &EventSenderBindings::LeapForward)
       .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)
@@ skipping 239 matching lines @@
 void EventSenderBindings::GestureScrollEnd(gin::Arguments* args) {
   if (sender_)
     sender_->GestureScrollEnd(args);
 }
 
 void EventSenderBindings::GestureScrollUpdate(gin::Arguments* args) {
   if (sender_)
     sender_->GestureScrollUpdate(args);
 }
 
+void EventSenderBindings::GesturePinchBegin(gin::Arguments* args) {
+  if (sender_)
+    sender_->GesturePinchBegin(args);
+}
+
+void EventSenderBindings::GesturePinchEnd(gin::Arguments* args) {
+  if (sender_)
+    sender_->GesturePinchEnd(args);
+}
+
+void EventSenderBindings::GesturePinchUpdate(gin::Arguments* args) {
+  if (sender_)
+    sender_->GesturePinchUpdate(args);
+}
+
 void EventSenderBindings::GestureTap(gin::Arguments* args) {
   if (sender_)
     sender_->GestureTap(args);
 }
 
 void EventSenderBindings::GestureTapDown(gin::Arguments* args) {
   if (sender_)
     sender_->GestureTapDown(args);
 }
 
@@ skipping 944 matching lines @@
 }
 
 void EventSender::GestureScrollEnd(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureScrollEnd, args);
 }
 
 void EventSender::GestureScrollUpdate(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureScrollUpdate, args);
 }
 
+void EventSender::GesturePinchBegin(gin::Arguments* args) {
+  GestureEvent(WebInputEvent::GesturePinchBegin, args);
+}
+
+void EventSender::GesturePinchEnd(gin::Arguments* args) {
+  GestureEvent(WebInputEvent::GesturePinchEnd, args);
+}
+
+void EventSender::GesturePinchUpdate(gin::Arguments* args) {
+  GestureEvent(WebInputEvent::GesturePinchUpdate, args);
+}
+
 void EventSender::GestureTap(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureTap, args);
 }
 
 void EventSender::GestureTapDown(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureTapDown, args);
 }
 
 void EventSender::GestureShowPress(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureShowPress, args);
@@ skipping 183 matching lines @@
     if (touch_point->state == WebTouchPoint::StateReleased) {
       touch_points_.erase(touch_points_.begin() + i);
       --i;
     } else
       touch_point->state = WebTouchPoint::StateStationary;
   }
 }
 
 void EventSender::GestureEvent(WebInputEvent::Type type,
                                gin::Arguments* args) {
+  WebGestureEvent event;
+  event.type = type;
+
+  // If the first argument is a string, it is to specify the device, otherwise
+  // the device is assumed to be a touchpad (this arrangement is because of
+  // a number of of pre-existing tests that made this assumption before this
+  // argument was added).

[Rick Byers, 2015/01/29 21:35:01]

are you sure about this part in the parens?  I believe the only type of gesture
events blink handles are touchscreen ones so all the existing code probably just
assumes it's touchscreen (touchpad fling gestures get handled by cc, but IIRC,
aren't passed to blink).  Doing this right probably means updating all existing
layout tests in fast/events/touch/gesture to specify  touchscreen.  Can you make
touchscreen the default instead?

[ccameron, 2015/01/29 21:54:09]

Oh -- I was going based on the undefined value's actual value (to the extent
that it was observed empirically), not the intention of the tests.

Updated the default to be touchscreen, and I'll see if the layout tests still
pass (if they don't, there are probably bugs to fix).

+  event.sourceDevice = blink::WebGestureDeviceTouchpad;
+  if (args->PeekNext()->IsString()) {
+    std::string device_string;
+    if (!args->GetNext(&device_string)) {
+      args->ThrowError();
+      return;
+    }
+    if (device_string == "touchpad") {
+      event.sourceDevice = blink::WebGestureDeviceTouchpad;
+    } else if (device_string == "touchscreen") {
+      event.sourceDevice = blink::WebGestureDeviceTouchscreen;
+    } else {
+      args->ThrowError();
+      return;
+    }
+  }
+
   double x;
   double y;
   if (!args->GetNext(&x) || !args->GetNext(&y)) {
     args->ThrowError();
     return;
   }
 
-  WebGestureEvent event;
-  event.type = type;
-
   switch (type) {
     case WebInputEvent::GestureScrollUpdate:
     {
       bool preventPropagation = false;
       if (!args->PeekNext().IsEmpty()) {
         if (!args->GetNext(&preventPropagation)) {
           args->ThrowError();
           return;
         }
       }
@@ skipping 12 matching lines @@
     case WebInputEvent::GestureScrollBegin:
       current_gesture_location_ = WebPoint(x, y);
       event.x = current_gesture_location_.x;
       event.y = current_gesture_location_.y;
       break;
     case WebInputEvent::GestureScrollEnd:
     case WebInputEvent::GestureFlingStart:
       event.x = current_gesture_location_.x;
       event.y = current_gesture_location_.y;
       break;
+    case WebInputEvent::GesturePinchBegin:
+    case WebInputEvent::GesturePinchEnd:
+      current_gesture_location_ = WebPoint(x, y);
+      event.x = current_gesture_location_.x;
+      event.y = current_gesture_location_.y;
+      break;
+    case WebInputEvent::GesturePinchUpdate:
+    {
+      float scale = 1;
+      if (!args->PeekNext().IsEmpty()) {
+        if (!args->GetNext(&scale)) {
+          args->ThrowError();
+          return;
+        }
+      }
+      event.data.pinchUpdate.scale = scale;
+      current_gesture_location_ = WebPoint(x, y);
+      event.x = current_gesture_location_.x;
+      event.y = current_gesture_location_.y;
+      break;
+    }
     case WebInputEvent::GestureTap:
     {
       float tap_count = 1;
       float width = 30;
       float height = 30;
       if (!args->PeekNext().IsEmpty()) {
         if (!args->GetNext(&tap_count)) {
           args->ThrowError();
           return;
         }
@@ skipping 339 matching lines @@
 
 bool EventSender::HandleInputEventOnViewOrPopup(const WebInputEvent& event) {
   if (WebPagePopup* popup = view_->pagePopup()) {
     if (!WebInputEvent::isKeyboardEventType(event.type))
       return popup->handleInputEvent(event);
   }
   return view_->handleInputEvent(event);
 }
 
 }  // namespace content