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 225 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:

[Rick Byers, 2015/01/29 20:43:27]

don't you need a way to specify the source device (touchpad / touchscreen)? 
Looks like we are probably getting away without this for GestureScroll events -
probably because only touchscreen scroll events ever make it to blink so blink
might not even check the source (but ideally we'd be explicitly initializing the
sourceDevice for all GestureScroll events to TouchScreen).

If you don't actually need to differentiate them in your code or have just a
DCHECK to verify it's only touchpad (sorry been swamped today - haven't looked
yet), then it's find to just hardcode to one value here.  Otherwise you may need
to take an extra param to set the sourceDevice.

[ccameron, 2015/01/29 21:30:40]

Well, I'll want to test that touchscreen events don't produce synthetic events,
too, so I'll need a type.

I had empirically noticed that the type was always touchpad ... BUT it turns out
that was just undefined behavior. I've updated this so that all gestures are by
default touchpad, but if the first argument is a string, that string can be
"touchpad" or "touchscreen" to differentiate the two.

+    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