Adding synthetic touch/mouse drag [Part1]

We have synthetic scroll. But this feature doesn’t work
in google maps in desktop version. To move around the maps we need
to use click and drag on mouse. This CL adds only the background
functions for synthetic click and drag and unittests.
feature for telemety tests. In case of touch screens, the drag is
identical to synthetic scroll already implemented, except
for adding slop.

The functions of class synthetic_smooth_scroll_gesture is moved to
synthetic_smooth_move_gesture, with additional features of drag drop.
Classes synthetic_smooth_scroll_gesture and
synthetic_smooth_drag_gesture use the features with an instance of
synthetic_smooth_move_gesture.

In the next CLs The API and javascript interfaces will be added.

BUG=457148

Review URL: https://codereview.chromium.org/929333002

Cr-Commit-Position: refs/heads/master@{#318071}

content/browser/renderer_host/input/synthetic_gesture.cc

@@ -7,6 +7,7 @@
 #include "base/logging.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target.h"
 #include "content/browser/renderer_host/input/synthetic_pinch_gesture.h"
+#include "content/browser/renderer_host/input/synthetic_smooth_drag_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_smooth_scroll_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_tap_gesture.h"
 
@@ -32,6 +33,9 @@ scoped_ptr<SyntheticGesture> SyntheticGesture::Create(
     case SyntheticGestureParams::SMOOTH_SCROLL_GESTURE:
       return CreateGesture<SyntheticSmoothScrollGesture,
                            SyntheticSmoothScrollGestureParams>(gesture_params);
+    case SyntheticGestureParams::SMOOTH_DRAG_GESTURE:
+      return CreateGesture<SyntheticSmoothDragGesture,
+                           SyntheticSmoothDragGestureParams>(gesture_params);
     case SyntheticGestureParams::PINCH_GESTURE:
       return CreateGesture<SyntheticPinchGesture,
                            SyntheticPinchGestureParams>(gesture_params);

content/browser/renderer_host/input/synthetic_smooth_drag_gesture.cc

+// Copyright 2015 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/browser/renderer_host/input/synthetic_smooth_drag_gesture.h"
+
+namespace content {
+
+SyntheticSmoothDragGesture::SyntheticSmoothDragGesture(
+    const SyntheticSmoothDragGestureParams& params)
+    : params_(params) {
+}
+
+SyntheticSmoothDragGesture::~SyntheticSmoothDragGesture() {
+}
+
+SyntheticGesture::Result SyntheticSmoothDragGesture::ForwardInputEvents(
+    const base::TimeTicks& timestamp,
+    SyntheticGestureTarget* target) {
+  if (!move_gesture_) {
+    if (!InitializeMoveGesture(params_.gesture_source_type, target))
+      return SyntheticGesture::GESTURE_SOURCE_TYPE_NOT_IMPLEMENTED;
+  }
+  return move_gesture_->ForwardInputEvents(timestamp, target);
+}
+
+SyntheticSmoothMoveGestureParams::InputType
+SyntheticSmoothDragGesture::GetInputSourceType(
+    SyntheticGestureParams::GestureSourceType gesture_source_type) {
+  if (gesture_source_type == SyntheticGestureParams::MOUSE_INPUT)
+    return SyntheticSmoothMoveGestureParams::MOUSE_DRAG_INPUT;
+  else
+    return SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
+}
+
+bool SyntheticSmoothDragGesture::InitializeMoveGesture(
+    SyntheticGestureParams::GestureSourceType gesture_type,
+    SyntheticGestureTarget* target) {
+  if (gesture_type == SyntheticGestureParams::DEFAULT_INPUT)
+    gesture_type = target->GetDefaultSyntheticGestureSourceType();
+
+  if (gesture_type == SyntheticGestureParams::TOUCH_INPUT ||
+      gesture_type == SyntheticGestureParams::MOUSE_INPUT) {
+    SyntheticSmoothMoveGestureParams move_params;
+    move_params.start_point = params_.start_point;
+    move_params.distances = params_.distances;
+    move_params.speed_in_pixels_s = params_.speed_in_pixels_s;
+    move_params.prevent_fling = true;
+    move_params.input_type = GetInputSourceType(gesture_type);
+    move_params.add_slop = false;
+    move_gesture_.reset(new SyntheticSmoothMoveGesture(move_params));
+    return true;
+  }
+  return false;
+}
+
+}  // namespace content

content/browser/renderer_host/input/synthetic_smooth_drag_gesture.h

+// Copyright 2015 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_SMOOTH_DRAG_GESTURE_H_
+#define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_SMOOTH_DRAG_GESTURE_H_
+
+#include "content/browser/renderer_host/input/synthetic_smooth_move_gesture.h"
+
+#include "content/common/input/synthetic_smooth_drag_gesture_params.h"
+
+namespace content {
+class CONTENT_EXPORT SyntheticSmoothDragGesture : public SyntheticGesture {
+ public:
+  explicit SyntheticSmoothDragGesture(
+      const SyntheticSmoothDragGestureParams& params);
+  ~SyntheticSmoothDragGesture() override;
+
+  // SyntheticGesture implementation:
+  SyntheticGesture::Result ForwardInputEvents(
+      const base::TimeTicks& timestamp,
+      SyntheticGestureTarget* target) override;
+
+ private:
+  static SyntheticSmoothMoveGestureParams::InputType GetInputSourceType(
+      SyntheticGestureParams::GestureSourceType gesture_source_type);
+
+  bool InitializeMoveGesture(
+      SyntheticGestureParams::GestureSourceType gesture_type,
+      SyntheticGestureTarget* target);
+
+  scoped_ptr<SyntheticSmoothMoveGesture> move_gesture_;
+  SyntheticSmoothDragGestureParams params_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_SMOOTH_DRAG_GESTURE_H_

content/browser/renderer_host/input/synthetic_smooth_move_gesture.h

+// Copyright 2013 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_SMOOTH_MOVE_GESTURE_H_
+#define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_SMOOTH_MOVE_GESTURE_H_
+
+#include <vector>
+
+#include "base/time/time.h"
+#include "content/browser/renderer_host/input/synthetic_gesture.h"
+#include "content/browser/renderer_host/input/synthetic_gesture_target.h"
+#include "content/common/content_export.h"
+#include "content/common/input/synthetic_smooth_drag_gesture_params.h"
+#include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
+#include "content/common/input/synthetic_web_input_event_builders.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace content {
+
+class CONTENT_EXPORT SyntheticSmoothMoveGestureParams {
+ public:
+  SyntheticSmoothMoveGestureParams();
+  ~SyntheticSmoothMoveGestureParams();
+
+  enum InputType { MOUSE_DRAG_INPUT, MOUSE_WHEEL_INPUT, TOUCH_INPUT };
+
+  InputType input_type;
+  gfx::PointF start_point;
+  std::vector<gfx::Vector2dF> distances;
+  int speed_in_pixels_s;
+  bool prevent_fling;
+  bool add_slop;
+};
+
+// This class is used as helper class for simulation of scroll and drag.
+// Simulates scrolling/dragging given a sequence of distances as a continuous
+// gestures (i.e. when synthesizing touch or mouse drag events, the pointer is
+// not lifted when changing scroll direction).
+// If no distance is provided or the first one is 0, no touch events are
+// generated.
+// When synthesizing touch events for scrolling, the first distance is extended
+// to compensate for the touch slop.
+class CONTENT_EXPORT SyntheticSmoothMoveGesture : public SyntheticGesture {
+ public:
+  SyntheticSmoothMoveGesture(SyntheticSmoothMoveGestureParams params);
+  ~SyntheticSmoothMoveGesture() override;
+
+  // SyntheticGesture implementation:
+  SyntheticGesture::Result ForwardInputEvents(
+      const base::TimeTicks& timestamp,
+      SyntheticGestureTarget* target) override;
+
+ private:
+  enum GestureState {
+    SETUP,
+    STARTED,
+    MOVING,
+    STOPPING,
+    DONE
+  };
+
+  void ForwardTouchInputEvents(
+      const base::TimeTicks& timestamp, SyntheticGestureTarget* target);
+  void ForwardMouseWheelInputEvents(
+      const base::TimeTicks& timestamp, SyntheticGestureTarget* target);
+  void ForwardMouseClickInputEvents(
+      const base::TimeTicks& timestamp, SyntheticGestureTarget* target);
+
+  void ForwardTouchEvent(SyntheticGestureTarget* target,
+                         const base::TimeTicks& timestamp);
+  void ForwardMouseWheelEvent(SyntheticGestureTarget* target,
+                              const gfx::Vector2dF& delta,
+                              const base::TimeTicks& timestamp) const;
+
+  void PressTouchPoint(SyntheticGestureTarget* target,
+                       const base::TimeTicks& timestamp);
+  void MoveTouchPoint(SyntheticGestureTarget* target,
+                      const gfx::Vector2dF& delta,
+                      const base::TimeTicks& timestamp);
+  void ReleaseTouchPoint(SyntheticGestureTarget* target,
+                         const base::TimeTicks& timestamp);
+
+  void PressMousePoint(SyntheticGestureTarget* target,
+                       const base::TimeTicks& timestamp);
+  void ReleaseMousePoint(SyntheticGestureTarget* target,
+                         const base::TimeTicks& timestamp);
+  void MoveMousePoint(SyntheticGestureTarget* target,
+                      const gfx::Vector2dF& delta,
+                      const base::TimeTicks& timestamp);
+
+  void AddTouchSlopToFirstDistance(SyntheticGestureTarget* target);
+  gfx::Vector2dF GetPositionDeltaAtTime(const base::TimeTicks& timestamp) const;
+  void ComputeNextMoveSegment();
+  base::TimeTicks ClampTimestamp(const base::TimeTicks& timestamp) const;
+  bool FinishedCurrentMoveSegment(const base::TimeTicks& timestamp) const;
+  bool IsLastMoveSegment() const;
+  bool MoveIsNoOp() const;
+
+  SyntheticSmoothMoveGestureParams params_;
+  // Used for mouse input.
+  gfx::Vector2d current_move_segment_total_delta_discrete_;
+  // Used for touch input.
+  gfx::PointF current_move_segment_start_position_;
+  SyntheticWebTouchEvent touch_event_;
+  GestureState state_;
+  int current_move_segment_;
+  base::TimeTicks current_move_segment_start_time_;
+  base::TimeTicks current_move_segment_stop_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(SyntheticSmoothMoveGesture);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_SMOOTH_MOVE_GESTURE_H_

content/browser/renderer_host/input/synthetic_smooth_scroll_gesture.h

@@ -5,85 +5,32 @@
 #ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_SMOOTH_SCROLL_GESTURE_H_
 #define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_SMOOTH_SCROLL_GESTURE_H_
 
-#include "base/time/time.h"
-#include "content/browser/renderer_host/input/synthetic_gesture.h"
-#include "content/browser/renderer_host/input/synthetic_gesture_target.h"
-#include "content/common/content_export.h"
+#include "content/browser/renderer_host/input/synthetic_smooth_move_gesture.h"
+
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
-#include "content/common/input/synthetic_web_input_event_builders.h"
-#include "third_party/WebKit/public/web/WebInputEvent.h"
-#include "ui/gfx/geometry/vector2d.h"
-#include "ui/gfx/geometry/vector2d_f.h"
 
 namespace content {
-
-// Simulates scrolling given a sequence of scroll distances as a continuous
-// gestures (i.e. when synthesizing touch events, the touch pointer is not
-// lifted when changing scroll direction).
-// If no distance is provided or the first one is 0, no touch events are
-// generated.
-// When synthesizing touch events, the first distance is extended to compensate
-// for the touch slop.
 class CONTENT_EXPORT SyntheticSmoothScrollGesture : public SyntheticGesture {
  public:
   explicit SyntheticSmoothScrollGesture(
       const SyntheticSmoothScrollGestureParams& params);
   ~SyntheticSmoothScrollGesture() override;
 
+  // SyntheticGesture implementation:
   SyntheticGesture::Result ForwardInputEvents(
       const base::TimeTicks& timestamp,
       SyntheticGestureTarget* target) override;
 
  private:
-  enum GestureState {
-    SETUP,
-    STARTED,
-    MOVING,
-    STOPPING,
-    DONE
-  };
-
-  void ForwardTouchInputEvents(
-      const base::TimeTicks& timestamp, SyntheticGestureTarget* target);
-  void ForwardMouseInputEvents(
-      const base::TimeTicks& timestamp, SyntheticGestureTarget* target);
+  static SyntheticSmoothMoveGestureParams::InputType GetInputSourceType(
+      SyntheticGestureParams::GestureSourceType gesture_source_type);
 
-  void ForwardTouchEvent(SyntheticGestureTarget* target,
-                         const base::TimeTicks& timestamp);
-  void ForwardMouseWheelEvent(SyntheticGestureTarget* target,
-                              const gfx::Vector2dF& delta,
-                              const base::TimeTicks& timestamp) const;
-
-  void PressTouchPoint(SyntheticGestureTarget* target,
-                       const base::TimeTicks& timestamp);
-  void MoveTouchPoint(SyntheticGestureTarget* target,
-                      const gfx::Vector2dF& delta,
-                      const base::TimeTicks& timestamp);
-  void ReleaseTouchPoint(SyntheticGestureTarget* target,
-                         const base::TimeTicks& timestamp);
-
-  void AddTouchSlopToFirstDistance(SyntheticGestureTarget* target);
-  gfx::Vector2dF GetPositionDeltaAtTime(const base::TimeTicks& timestamp)
-      const;
-  void ComputeNextScrollSegment();
-  base::TimeTicks ClampTimestamp(const base::TimeTicks& timestamp) const;
-  bool FinishedCurrentScrollSegment(const base::TimeTicks& timestamp) const;
-  bool IsLastScrollSegment() const;
-  bool ScrollIsNoOp() const;
+  bool InitializeMoveGesture(
+      SyntheticGestureParams::GestureSourceType gesture_type,
+      SyntheticGestureTarget* target);
 
+  scoped_ptr<SyntheticSmoothMoveGesture> move_gesture_;
   SyntheticSmoothScrollGestureParams params_;
-  // Used for mouse input.
-  gfx::Vector2d current_scroll_segment_total_delta_discrete_;
-  // Used for touch input.
-  gfx::Point current_scroll_segment_start_position_;
-  SyntheticWebTouchEvent touch_event_;
-  SyntheticGestureParams::GestureSourceType gesture_source_type_;
-  GestureState state_;
-  int current_scroll_segment_;
-  base::TimeTicks current_scroll_segment_start_time_;
-  base::TimeTicks current_scroll_segment_stop_time_;
-
-  DISALLOW_COPY_AND_ASSIGN(SyntheticSmoothScrollGesture);
 };
 
 }  // namespace content

content/common/input/input_param_traits.cc

@@ -70,6 +70,10 @@ void ParamTraits<content::SyntheticGesturePacket>::Write(Message* m,
       WriteParam(m, *content::SyntheticTapGestureParams::Cast(
           p.gesture_params()));
       break;
+    // TODO(ssid): When API and IPC messages are set up, implement this.
+    case content::SyntheticGestureParams::SMOOTH_DRAG_GESTURE:
+      NOTIMPLEMENTED();
+      break;
   }
 }
 
@@ -122,6 +126,10 @@ void ParamTraits<content::SyntheticGesturePacket>::Log(const param_type& p,
           *content::SyntheticTapGestureParams::Cast(p.gesture_params()),
           l);
       break;
+    // TODO(ssid): When API and IPC messages are set up, implement this.
+    case content::SyntheticGestureParams::SMOOTH_DRAG_GESTURE:
+      NOTIMPLEMENTED();
+      break;
   }
 }
 

content/common/input/input_param_traits_unittest.cc

@@ -7,6 +7,7 @@
 #include "content/common/input/input_event.h"
 #include "content/common/input/synthetic_gesture_params.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
+#include "content/common/input/synthetic_smooth_drag_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/common/input_messages.h"
 #include "ipc/ipc_message.h"
@@ -43,11 +44,21 @@ class InputParamTraitsTest : public testing::Test {
     EXPECT_EQ(a->anchor, b->anchor);
     EXPECT_EQ(a->distances.size(), b->distances.size());
     for (size_t i = 0; i < a->distances.size(); i++)
-        EXPECT_EQ(a->distances[i], b->distances[i]);
+      EXPECT_EQ(a->distances[i], b->distances[i]);
     EXPECT_EQ(a->prevent_fling, b->prevent_fling);
     EXPECT_EQ(a->speed_in_pixels_s, b->speed_in_pixels_s);
   }
 
+  static void Compare(const SyntheticSmoothDragGestureParams* a,
+                      const SyntheticSmoothDragGestureParams* b) {
+    EXPECT_EQ(a->gesture_source_type, b->gesture_source_type);
+    EXPECT_EQ(a->start_point, b->start_point);
+    EXPECT_EQ(a->distances.size(), b->distances.size());
+    for (size_t i = 0; i < a->distances.size(); i++)
+      EXPECT_EQ(a->distances[i], b->distances[i]);
+    EXPECT_EQ(a->speed_in_pixels_s, b->speed_in_pixels_s);
+  }
+
   static void Compare(const SyntheticPinchGestureParams* a,
                       const SyntheticPinchGestureParams* b) {
     EXPECT_EQ(a->gesture_source_type, b->gesture_source_type);
@@ -77,6 +88,10 @@ class InputParamTraitsTest : public testing::Test {
         Compare(SyntheticSmoothScrollGestureParams::Cast(a->gesture_params()),
                 SyntheticSmoothScrollGestureParams::Cast(b->gesture_params()));
         break;
+      case SyntheticGestureParams::SMOOTH_DRAG_GESTURE:
+        Compare(SyntheticSmoothDragGestureParams::Cast(a->gesture_params()),
+                SyntheticSmoothDragGestureParams::Cast(b->gesture_params()));
+        break;
       case SyntheticGestureParams::PINCH_GESTURE:
         Compare(SyntheticPinchGestureParams::Cast(a->gesture_params()),
                 SyntheticPinchGestureParams::Cast(b->gesture_params()));

content/common/input/synthetic_gesture_params.h

@@ -45,6 +45,7 @@ struct CONTENT_EXPORT SyntheticGestureParams {
 
   enum GestureType {
     SMOOTH_SCROLL_GESTURE,
+    SMOOTH_DRAG_GESTURE,
     PINCH_GESTURE,
     TAP_GESTURE,
     SYNTHETIC_GESTURE_TYPE_MAX = TAP_GESTURE

content/common/input/synthetic_smooth_drag_gesture_params.cc

+// Copyright 2015 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/common/input/synthetic_smooth_drag_gesture_params.h"
+
+#include "base/logging.h"
+
+namespace content {
+namespace {
+
+const int kDefaultSpeedInPixelsPerSec = 800;
+
+}  // namespace
+
+SyntheticSmoothDragGestureParams::SyntheticSmoothDragGestureParams()
+    : speed_in_pixels_s(kDefaultSpeedInPixelsPerSec) {
+}
+
+SyntheticSmoothDragGestureParams::SyntheticSmoothDragGestureParams(
+    const SyntheticSmoothDragGestureParams& other)
+    : SyntheticGestureParams(other),
+      start_point(other.start_point),
+      distances(other.distances),
+      speed_in_pixels_s(other.speed_in_pixels_s) {
+}
+
+SyntheticSmoothDragGestureParams::~SyntheticSmoothDragGestureParams() {
+}
+
+SyntheticGestureParams::GestureType
+SyntheticSmoothDragGestureParams::GetGestureType() const {
+  return SMOOTH_DRAG_GESTURE;
+}
+
+const SyntheticSmoothDragGestureParams* SyntheticSmoothDragGestureParams::Cast(
+    const SyntheticGestureParams* gesture_params) {
+  DCHECK(gesture_params);
+  DCHECK_EQ(SMOOTH_DRAG_GESTURE, gesture_params->GetGestureType());
+  return static_cast<const SyntheticSmoothDragGestureParams*>(gesture_params);
+}
+
+}  // namespace content

content/common/input/synthetic_smooth_drag_gesture_params.h

+// Copyright 2015 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.
+
+#ifndef CONTENT_COMMON_INPUT_SYNTHETIC_SMOOTH_DRAG_GESTURE_PARAMS_H_
+#define CONTENT_COMMON_INPUT_SYNTHETIC_SMOOTH_DRAG_GESTURE_PARAMS_H_
+
+#include <vector>
+
+#include "content/common/content_export.h"
+#include "content/common/input/synthetic_gesture_params.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/vector2d.h"
+
+namespace content {
+
+struct CONTENT_EXPORT SyntheticSmoothDragGestureParams
+    : public SyntheticGestureParams {
+ public:
+  SyntheticSmoothDragGestureParams();
+  SyntheticSmoothDragGestureParams(
+      const SyntheticSmoothDragGestureParams& other);
+  ~SyntheticSmoothDragGestureParams() override;
+
+  GestureType GetGestureType() const override;
+
+  gfx::PointF start_point;
+  std::vector<gfx::Vector2dF> distances;
+  int speed_in_pixels_s;
+
+  static const SyntheticSmoothDragGestureParams* Cast(
+      const SyntheticGestureParams* gesture_params);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_COMMON_INPUT_SYNTHETIC_SMOOTH_DRAG_GESTURE_PARAMS_H_

content/content_browser.gypi

@@ -1087,6 +1087,10 @@
       'browser/renderer_host/input/synthetic_gesture_target_base.h',
       'browser/renderer_host/input/synthetic_pinch_gesture.cc',
       'browser/renderer_host/input/synthetic_pinch_gesture.h',
+      'browser/renderer_host/input/synthetic_smooth_drag_gesture.cc',
+      'browser/renderer_host/input/synthetic_smooth_drag_gesture.h',
+      'browser/renderer_host/input/synthetic_smooth_move_gesture.cc',
+      'browser/renderer_host/input/synthetic_smooth_move_gesture.h',
       'browser/renderer_host/input/synthetic_smooth_scroll_gesture.cc',
       'browser/renderer_host/input/synthetic_smooth_scroll_gesture.h',
       'browser/renderer_host/input/synthetic_tap_gesture.cc',

content/content_common.gypi

@@ -369,6 +369,8 @@
       'common/input/synthetic_gesture_params.h',
       'common/input/synthetic_pinch_gesture_params.cc',
       'common/input/synthetic_pinch_gesture_params.h',
+      'common/input/synthetic_smooth_drag_gesture_params.cc',
+      'common/input/synthetic_smooth_drag_gesture_params.h',
       'common/input/synthetic_smooth_scroll_gesture_params.cc',
       'common/input/synthetic_smooth_scroll_gesture_params.h',
       'common/input/synthetic_tap_gesture_params.cc',