EventSender::GestureFlingStart takes a source_device.

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 327 matching lines @@
 bool IsSystemKeyEvent(const WebKeyboardEvent& event) {
 #if defined(OS_MACOSX)
   return event.modifiers & WebInputEvent::MetaKey &&
       event.windowsKeyCode != ui::VKEY_B &&
       event.windowsKeyCode != ui::VKEY_I;
 #else
   return !!(event.modifiers & WebInputEvent::AltKey);
 #endif
 }
 
+const char* kSourceDeviceStringTouchpad = "touchpad";
+const char* kSourceDeviceStringTouchscreen = "touchscreen";
+
 }  // namespace
 
 class EventSenderBindings : public gin::Wrappable<EventSenderBindings> {
  public:
   static gin::WrapperInfo kWrapperInfo;
 
   static void Install(base::WeakPtr<EventSender> sender,
                       blink::WebFrame* frame);
 
  private:
@@ skipping 17 matching lines @@
   void SetPageScaleFactor(gin::Arguments* args);
   void SetPageScaleFactorLimits(gin::Arguments* args);
   void ClearTouchPoints();
   void ReleaseTouchPoint(unsigned index);
   void UpdateTouchPoint(unsigned index, double x, double y);
   void CancelTouchPoint(unsigned index);
   void SetTouchModifier(const std::string& key_name, bool set_mask);
   void SetTouchCancelable(bool cancelable);
   void DumpFilenameBeingDragged();
   void GestureFlingCancel();
-  void GestureFlingStart(float x, float y, float velocity_x, float velocity_y);
+  void GestureFlingStart(float x,
+                         float y,
+                         float velocity_x,
+                         float velocity_y,
+                         gin::Arguments* args);
   void GestureScrollFirstPoint(int x, int y);
   void TouchStart();
   void TouchMove();
   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();
@@ skipping 314 matching lines @@
 void EventSenderBindings::DumpFilenameBeingDragged() {
   if (sender_)
     sender_->DumpFilenameBeingDragged();
 }
 
 void EventSenderBindings::GestureFlingCancel() {
   if (sender_)
     sender_->GestureFlingCancel();
 }
 
+// TODO(tdresser): Once we've migrated all calls to GestureFlingStart
+// to pass the device_string, change |args| to |std::string
+// device_string|. See crbug.com/456136 for details.
 void EventSenderBindings::GestureFlingStart(float x,
                                             float y,
                                             float velocity_x,
-                                            float velocity_y) {
+                                            float velocity_y,
+                                            gin::Arguments* args) {
+  std::string device_string = kSourceDeviceStringTouchpad;
+  if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString()) {
+    if (!args->GetNext(&device_string)) {
+      args->ThrowError();
+      return;
+    }
+  }
   if (sender_)
-    sender_->GestureFlingStart(x, y, velocity_x, velocity_y);
+    sender_->GestureFlingStart(x, y, velocity_x, velocity_y, device_string);
 }
 
 void EventSenderBindings::GestureScrollFirstPoint(int x, int y) {
   if (sender_)
     sender_->GestureScrollFirstPoint(x, y);
 }
 
 void EventSenderBindings::TouchStart() {
   if (sender_)
     sender_->TouchStart();
@@ skipping 864 matching lines @@
   event.type = WebInputEvent::GestureFlingCancel;
   event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
     view_->layout();
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::GestureFlingStart(float x,
-                                     float y,
-                                     float velocity_x,
-                                     float velocity_y) {
+                                    float y,
+                                    float velocity_x,
+                                    float velocity_y,
+                                    std::string device_string) {
   WebGestureEvent event;
   event.type = WebInputEvent::GestureFlingStart;
 
+  event.sourceDevice = blink::WebGestureDeviceTouchscreen;

[Rick Byers, 2015/02/07 11:20:23]

This should probably have logic similar to GestureEvent below where unrecognized
strings throw an error, right?

[tdresser, 2015/02/09 14:48:08]

My plan was to switch to use |std::string| instead of |gin::Arguments| once I've
updated blink to always pass a device_string. Without a |gin::Arguments|, you
can't throw an error.

This approach has precedent, for example, EventSender::MouseDown defaults to
assuming a middle click.
https://code.google.com/p/chromium/codesearch#chromium/src/content/shell/rend...

If you'd prefer, I can switch to always passing a |gin::Arguments|.

+  if (device_string == kSourceDeviceStringTouchpad)
+    event.sourceDevice = blink::WebGestureDeviceTouchpad;
+
   event.x = x;
   event.y = y;
   event.globalX = event.x;
   event.globalY = event.y;
 
   event.data.flingStart.velocityX = velocity_x;
   event.data.flingStart.velocityY = velocity_y;
   event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
@@ skipping 365 matching lines @@
   // If the first argument is a string, it is to specify the device, otherwise
   // the device is assumed to be a touchscreen (since most tests were written
   // assuming this).
   event.sourceDevice = blink::WebGestureDeviceTouchscreen;
   if (args->PeekNext()->IsString()) {
     std::string device_string;
     if (!args->GetNext(&device_string)) {
       args->ThrowError();
       return;
     }
-    if (device_string == "touchpad") {
+    if (device_string == kSourceDeviceStringTouchpad) {
       event.sourceDevice = blink::WebGestureDeviceTouchpad;
-    } else if (device_string == "touchscreen") {
+    } else if (device_string == kSourceDeviceStringTouchscreen) {
       event.sourceDevice = blink::WebGestureDeviceTouchscreen;
     } else {
       args->ThrowError();
       return;
     }
   }
 
   double x;
   double y;
   if (!args->GetNext(&x) || !args->GetNext(&y)) {
@@ skipping 406 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