Adding synthetic touch/mouse drag [Part1]

content/browser/renderer_host/input/synthetic_gesture_controller_unittest.cc

 // 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.
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "content/browser/renderer_host/input/synthetic_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_controller.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_move_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_smooth_scroll_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_tap_gesture.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.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/synthetic_tap_gesture_params.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/test/test_render_view_host.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/geometry/vector2d_f.h"
 
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 
 namespace content {
 
 namespace {
 
 const int kFlushInputRateInMs = 16;
 const int kPointerAssumedStoppedTimeMs = 43;
 const float kTouchSlopInDips = 7.0f;
 const float kMinScalingSpanInDips = 27.5f;
 
+enum TouchGestureType { TOUCH_SCROLL, TOUCH_DRAG };
+
 class MockSyntheticGesture : public SyntheticGesture {
  public:
   MockSyntheticGesture(bool* finished, int num_steps)
       : finished_(finished),
         num_steps_(num_steps),
         step_count_(0) {
     *finished_ = false;
   }
   ~MockSyntheticGesture() override {}
 
@@ skipping 51 matching lines @@
 
   bool flush_requested() const { return flush_requested_; }
   void ClearFlushRequest() { flush_requested_ = false; }
 
  private:
   bool flush_requested_;
 
   int pointer_assumed_stopped_time_ms_;
 };
 
-class MockScrollGestureTarget : public MockSyntheticGestureTarget {
+class MockMoveGestureTarget : public MockSyntheticGestureTarget {
  public:
-  MockScrollGestureTarget() : total_abs_scroll_distance_length_(0) {}
-  ~MockScrollGestureTarget() override {}
+  MockMoveGestureTarget() : total_abs_move_distance_length_(0) {}
+  ~MockMoveGestureTarget() override {}
 
   gfx::Vector2dF start_to_end_distance() const {
     return start_to_end_distance_;
   }
-  float total_abs_scroll_distance_length() const {
-    return total_abs_scroll_distance_length_;
+  float total_abs_move_distance_length() const {
+    return total_abs_move_distance_length_;
   }
 
  protected:
   gfx::Vector2dF start_to_end_distance_;
-  float total_abs_scroll_distance_length_;
+  float total_abs_move_distance_length_;
 };
 
-class MockScrollMouseTarget : public MockScrollGestureTarget {
+class MockScrollMouseTarget : public MockMoveGestureTarget {
  public:
   MockScrollMouseTarget() {}
   ~MockScrollMouseTarget() override {}
 
   void DispatchInputEventToPlatform(const WebInputEvent& event) override {
     ASSERT_EQ(event.type, WebInputEvent::MouseWheel);
     const WebMouseWheelEvent& mouse_wheel_event =
         static_cast<const WebMouseWheelEvent&>(event);
     gfx::Vector2dF delta(mouse_wheel_event.deltaX, mouse_wheel_event.deltaY);
     start_to_end_distance_ += delta;
-    total_abs_scroll_distance_length_ += delta.Length();
+    total_abs_move_distance_length_ += delta.Length();
   }
 };
 
-class MockScrollTouchTarget : public MockScrollGestureTarget {
+class MockMoveTouchTarget : public MockMoveGestureTarget {
  public:
-  MockScrollTouchTarget() : started_(false) {}
-  ~MockScrollTouchTarget() override {}
+  MockMoveTouchTarget() : started_(false) {}
+  ~MockMoveTouchTarget() override {}
 
   void DispatchInputEventToPlatform(const WebInputEvent& event) override {
     ASSERT_TRUE(WebInputEvent::isTouchEventType(event.type));
     const WebTouchEvent& touch_event = static_cast<const WebTouchEvent&>(event);
     ASSERT_EQ(touch_event.touchesLength, 1U);
 
     if (!started_) {
       ASSERT_EQ(touch_event.type, WebInputEvent::TouchStart);
       start_.SetPoint(touch_event.touches[0].position.x,
                       touch_event.touches[0].position.y);
       last_touch_point_ = start_;
       started_ = true;
     } else {
       ASSERT_NE(touch_event.type, WebInputEvent::TouchStart);
       ASSERT_NE(touch_event.type, WebInputEvent::TouchCancel);
 
       gfx::PointF touch_point(touch_event.touches[0].position.x,
                               touch_event.touches[0].position.y);
       gfx::Vector2dF delta = touch_point - last_touch_point_;
-      total_abs_scroll_distance_length_ += delta.Length();
+      total_abs_move_distance_length_ += delta.Length();
 
       if (touch_event.type == WebInputEvent::TouchEnd)
         start_to_end_distance_ = touch_point - start_;
 
       last_touch_point_ = touch_point;
     }
   }
 
  protected:
   gfx::Point start_;
   gfx::PointF last_touch_point_;
   bool started_;
 };
 
+class MockDragMouseTarget : public MockMoveGestureTarget {
+ public:
+  MockDragMouseTarget() : started_(false) {}
+  ~MockDragMouseTarget() override {}
+
+  void DispatchInputEventToPlatform(const WebInputEvent& event) override {
+    ASSERT_TRUE(WebInputEvent::isMouseEventType(event.type));
+    const WebMouseEvent& mouse_event = static_cast<const WebMouseEvent&>(event);
+    if (!started_) {
+      EXPECT_EQ(mouse_event.button, WebMouseEvent::ButtonLeft);
+      EXPECT_EQ(mouse_event.clickCount, 1);
+      EXPECT_EQ(mouse_event.type, WebInputEvent::MouseDown);
+      start_.SetPoint(mouse_event.x, mouse_event.y);
+      last_mouse_point_ = start_;
+      started_ = true;
+    } else {
+      EXPECT_EQ(mouse_event.button, WebMouseEvent::ButtonLeft);
+      ASSERT_NE(mouse_event.type, WebInputEvent::MouseDown);
+
+      gfx::PointF mouse_point(mouse_event.x, mouse_event.y);
+      gfx::Vector2dF delta = mouse_point - last_mouse_point_;
+      total_abs_move_distance_length_ += delta.Length();
+      if (mouse_event.type == WebInputEvent::MouseUp)
+        start_to_end_distance_ = mouse_point - start_;
+      last_mouse_point_ = mouse_point;
+    }
+  }
+
+ private:
+  bool started_;
+  gfx::PointF start_, last_mouse_point_;
+};
+
 class MockSyntheticPinchTouchTarget : public MockSyntheticGestureTarget {
  public:
   enum ZoomDirection {
     ZOOM_DIRECTION_UNKNOWN,
     ZOOM_IN,
     ZOOM_OUT
   };
 
   MockSyntheticPinchTouchTarget()
       : initial_pointer_distance_(0),
@@ skipping 156 matching lines @@
             static_cast<int64>(mouse_event.timeStampSeconds * 1000));
         state_ = FINISHED;
         break;
       case FINISHED:
         EXPECT_FALSE(true);
         break;
     }
   }
 };
 
-class SyntheticGestureControllerTest : public testing::Test {
+class SyntheticGestureControllerTestBase {
  public:
-  SyntheticGestureControllerTest() {}
-  ~SyntheticGestureControllerTest() override {}
+  SyntheticGestureControllerTestBase() {}
+  ~SyntheticGestureControllerTestBase() {}
 
  protected:
   template<typename MockGestureTarget>
   void CreateControllerAndTarget() {
     target_ = new MockGestureTarget();
     controller_.reset(new SyntheticGestureController(
         scoped_ptr<SyntheticGestureTarget>(target_)));
   }
 
-  void SetUp() override {
-    start_time_ = base::TimeTicks::Now();
-    time_ = start_time_;
-    num_success_ = 0;
-    num_failure_ = 0;
-  }
-
-  void TearDown() override {
-    controller_.reset();
-    target_ = NULL;
-    time_ = base::TimeTicks();
-  }
-
   void QueueSyntheticGesture(scoped_ptr<SyntheticGesture> gesture) {
-    controller_->QueueSyntheticGesture(gesture.Pass(),
-        base::Bind(&SyntheticGestureControllerTest::OnSyntheticGestureCompleted,
+    controller_->QueueSyntheticGesture(
+        gesture.Pass(),
+        base::Bind(
+            &SyntheticGestureControllerTestBase::OnSyntheticGestureCompleted,
             base::Unretained(this)));
   }
 
   void FlushInputUntilComplete() {
     while (target_->flush_requested()) {
       while (target_->flush_requested()) {
         target_->ClearFlushRequest();
         time_ += base::TimeDelta::FromMilliseconds(kFlushInputRateInMs);
         controller_->Flush(time_);
       }
@@ skipping 12 matching lines @@
   base::TimeDelta GetTotalTime() const { return time_ - start_time_; }
 
   MockSyntheticGestureTarget* target_;
   scoped_ptr<SyntheticGestureController> controller_;
   base::TimeTicks start_time_;
   base::TimeTicks time_;
   int num_success_;
   int num_failure_;
 };
 
+class SyntheticGestureControllerTest
+    : public SyntheticGestureControllerTestBase,
+      public testing::Test {
+ protected:
+  void SetUp() override {
+    start_time_ = base::TimeTicks::Now();
+    time_ = start_time_;
+    num_success_ = 0;
+    num_failure_ = 0;
+  }
+
+  void TearDown() override {
+    controller_.reset();
+    target_ = NULL;
+    time_ = base::TimeTicks();
+  }
+};
+
+class SyntheticGestureControllerTestWithParam
+    : public SyntheticGestureControllerTestBase,
+      public testing::TestWithParam<bool> {
+ protected:
+  void SetUp() override {
+    start_time_ = base::TimeTicks::Now();
+    time_ = start_time_;
+    num_success_ = 0;
+    num_failure_ = 0;
+  }
+
+  void TearDown() override {
+    controller_.reset();
+    target_ = NULL;
+    time_ = base::TimeTicks();
+  }
+};
+
 TEST_F(SyntheticGestureControllerTest, SingleGesture) {
   CreateControllerAndTarget<MockSyntheticGestureTarget>();
 
   bool finished = false;
   scoped_ptr<MockSyntheticGesture> gesture(
       new MockSyntheticGesture(&finished, 3));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
   EXPECT_TRUE(finished);
@@ skipping 87 matching lines @@
   while (target_->flush_requested()) {
     target_->ClearFlushRequest();
     time_ += base::TimeDelta::FromMilliseconds(kFlushInputRateInMs);
     controller_->Flush(time_);
   }
   EXPECT_EQ(1, num_success_);
   controller_->OnDidFlushInput();
   EXPECT_EQ(2, num_success_);
 }
 
-gfx::Vector2d AddTouchSlopToVector(const gfx::Vector2d& vector,
+gfx::Vector2d AddTouchSlopToVector(const gfx::Vector2dF& vector,
                                    SyntheticGestureTarget* target) {
   const int kTouchSlop = target->GetTouchSlopInDips();
 
   int x = vector.x();
   if (x > 0)
     x += kTouchSlop;
   else if (x < 0)
     x -= kTouchSlop;
 
   int y = vector.y();
   if (y > 0)
     y += kTouchSlop;
   else if (y < 0)
     y -= kTouchSlop;
 
   return gfx::Vector2d(x, y);
 }
 
-TEST_F(SyntheticGestureControllerTest, SingleScrollGestureTouchVertical) {
-  CreateControllerAndTarget<MockScrollTouchTarget>();
+TEST_P(SyntheticGestureControllerTestWithParam,
+       SingleMoveGestureTouchVertical) {
+  CreateControllerAndTarget<MockMoveTouchTarget>();
 
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.anchor.SetPoint(89, 32);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
+  if (GetParam() == TOUCH_SCROLL) {

[picksi, 2015/02/23 12:22:24]

BTW I don't believe you named the function 'GetParam', but it is a nasty
function name; it is very generic and seems unrelated to the value
(TOUCH_SCROLL) it is being compared to. As part of a future refactor it might be
nice to re-name this GetInteractionType (or whatever more accurately relfects
its use).

[ssid, 2015/02/23 14:03:04]

The GetParam is function given by TEST_P inplementation. the meaning of the
param can be understood from the enum values.

+    params.prevent_slop = false;
+  } else {
+    params.prevent_slop = true;

[picksi, 2015/02/23 12:22:24]

Bikeshedding (ish) : Should this true/false setting be done the 'params' itself?
i.e. 

params.setSlopFromType( GetParam() );

... to remove duplicate code and keep knowledge about 'params' inside params?

[ssid, 2015/02/23 14:03:04]

The type here is defined only in the test. It need not be known to the class
itself.

+  }
+  params.start_point.SetPoint(89, 32);
   params.distances.push_back(gfx::Vector2d(0, 123));
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
-  EXPECT_EQ(AddTouchSlopToVector(params.distances[0], target_),
-            scroll_target->start_to_end_distance());
+  if (GetParam() == TOUCH_SCROLL) {
+    EXPECT_EQ(AddTouchSlopToVector(params.distances[0], target_),
+              scroll_target->start_to_end_distance());
+  } else {
+    EXPECT_EQ(params.distances[0], scroll_target->start_to_end_distance());
+  }
 }
 
-TEST_F(SyntheticGestureControllerTest, SingleScrollGestureTouchHorizontal) {
-  CreateControllerAndTarget<MockScrollTouchTarget>();
+TEST_P(SyntheticGestureControllerTestWithParam,
+       SingleScrollGestureTouchHorizontal) {
+  CreateControllerAndTarget<MockMoveTouchTarget>();
 
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.anchor.SetPoint(12, -23);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
+  if (GetParam() == TOUCH_SCROLL) {
+    params.prevent_slop = false;
+  } else {
+    params.prevent_slop = true;
+  }
+  params.start_point.SetPoint(12, -23);
   params.distances.push_back(gfx::Vector2d(-234, 0));
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
-  EXPECT_EQ(AddTouchSlopToVector(params.distances[0], target_),
-            scroll_target->start_to_end_distance());
+  if (GetParam() == TOUCH_SCROLL) {

[picksi, 2015/02/23 12:22:24]

Since you've already used GetParam() to set prevent_slop, it feels like this
value (params.prevent_slop) is the value you should be checking here ... I
assume it is the extra slop that requires the different test; the fact it is a
TOUCH_SCROLL feels like 'just' an implementation detail... i.e. if different
input types get slop in the future this code will fail.

[ssid, 2015/02/23 14:03:04]

The value of prevent_slop is a consequence of the GetParam value. checking for
that will make the code little unreadable I think. What can be done is have a
variable set by GetParam and then check that at both places, but I thought it
was complexity not necessary, so avoided it.

[picksi, 2015/02/23 14:24:27]

Hmm. I still think (something like):

float expected_distance;
if (params.prevent_slop) {
  expected_distance = params.distances[0];
}
else
{
  expected_distance = AddTouchSlopToVector(params.distances[0], target_);
}
EXPECT_EQ(expected_distance,scroll_target->start_to_end_distance());

would be more future-proof and readable than checking for the touch-type again
(although it is more verbose). @Sami can you provide a casting vote?

[Sami, 2015/02/23 18:03:27]

I'm leaning toward repeating the GetParam() call because it makes it easier to
eyeball where the two paths diverge.

+    EXPECT_EQ(AddTouchSlopToVector(params.distances[0], target_),
+              scroll_target->start_to_end_distance());
+  } else {
+    EXPECT_EQ(params.distances[0], scroll_target->start_to_end_distance());
+  }
 }
 
 void CheckIsWithinRangeSingle(float scroll_distance,
                               int target_distance,
                               SyntheticGestureTarget* target) {
   if (target_distance > 0) {
     EXPECT_LE(target_distance, scroll_distance);
     EXPECT_LE(scroll_distance, target_distance + target->GetTouchSlopInDips());
   } else {
     EXPECT_GE(target_distance, scroll_distance);
     EXPECT_GE(scroll_distance, target_distance - target->GetTouchSlopInDips());
   }
 }
 
 void CheckSingleScrollDistanceIsWithinRange(
     const gfx::Vector2dF& scroll_distance,
-    const gfx::Vector2d& target_distance,
+    const gfx::Vector2dF& target_distance,
     SyntheticGestureTarget* target) {
   CheckIsWithinRangeSingle(scroll_distance.x(), target_distance.x(), target);
   CheckIsWithinRangeSingle(scroll_distance.y(), target_distance.y(), target);
 }
 
 TEST_F(SyntheticGestureControllerTest, SingleScrollGestureTouchDiagonal) {
-  CreateControllerAndTarget<MockScrollTouchTarget>();
+  CreateControllerAndTarget<MockMoveTouchTarget>();
 
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.anchor.SetPoint(0, 7);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
+  params.start_point.SetPoint(0, 7);
   params.distances.push_back(gfx::Vector2d(413, -83));
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   CheckSingleScrollDistanceIsWithinRange(
       scroll_target->start_to_end_distance(), params.distances[0], target_);
 }
 
 TEST_F(SyntheticGestureControllerTest, SingleScrollGestureTouchLongStop) {
-  CreateControllerAndTarget<MockScrollTouchTarget>();
+  CreateControllerAndTarget<MockMoveTouchTarget>();
 
   // Create a smooth scroll with a short distance and set the pointer assumed
   // stopped time high, so that the stopping should dominate the time the
   // gesture is active.
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.anchor.SetPoint(-98, -23);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
+  params.start_point.SetPoint(-98, -23);
   params.distances.push_back(gfx::Vector2d(21, -12));
   params.prevent_fling = true;
 
   target_->set_pointer_assumed_stopped_time_ms(543);
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   CheckSingleScrollDistanceIsWithinRange(
       scroll_target->start_to_end_distance(), params.distances[0], target_);
   EXPECT_GE(GetTotalTime(), target_->PointerAssumedStoppedTime());
 }
 
 TEST_F(SyntheticGestureControllerTest, SingleScrollGestureTouchFling) {
-  CreateControllerAndTarget<MockScrollTouchTarget>();
+  CreateControllerAndTarget<MockMoveTouchTarget>();
 
   // Create a smooth scroll with a short distance and set the pointer assumed
   // stopped time high. Disable 'prevent_fling' and check that the gesture
   // finishes without waiting before it stops.
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.anchor.SetPoint(-89, 78);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
+  params.start_point.SetPoint(-89, 78);
   params.distances.push_back(gfx::Vector2d(-43, 19));
   params.prevent_fling = false;
 
   target_->set_pointer_assumed_stopped_time_ms(543);
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   CheckSingleScrollDistanceIsWithinRange(
       scroll_target->start_to_end_distance(), params.distances[0], target_);
   EXPECT_LE(GetTotalTime(), target_->PointerAssumedStoppedTime());
 }
 
-TEST_F(SyntheticGestureControllerTest, SingleScrollGestureTouchZeroDistance) {
-  CreateControllerAndTarget<MockScrollTouchTarget>();
+TEST_P(SyntheticGestureControllerTestWithParam,
+       SingleScrollGestureTouchZeroDistance) {
+  CreateControllerAndTarget<MockMoveTouchTarget>();
 
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.anchor.SetPoint(-32, 43);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
+  if (GetParam() == TOUCH_SCROLL) {
+    params.prevent_slop = false;
+  } else {
+    params.prevent_slop = true;
+  }
+  params.start_point.SetPoint(-32, 43);
   params.distances.push_back(gfx::Vector2d(0, 0));
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(gfx::Vector2dF(0, 0), scroll_target->start_to_end_distance());
 }
 
 TEST_F(SyntheticGestureControllerTest, SingleScrollGestureMouseVertical) {
   CreateControllerAndTarget<MockScrollMouseTarget>();
 
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
-  params.anchor.SetPoint(432, 89);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::MOUSE_WHEEL_INPUT;
+  params.start_point.SetPoint(432, 89);
   params.distances.push_back(gfx::Vector2d(0, -234));
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(params.distances[0], scroll_target->start_to_end_distance());
 }
 
 TEST_F(SyntheticGestureControllerTest, SingleScrollGestureMouseHorizontal) {
   CreateControllerAndTarget<MockScrollMouseTarget>();
 
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
-  params.anchor.SetPoint(90, 12);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::MOUSE_WHEEL_INPUT;
+  params.start_point.SetPoint(90, 12);
   params.distances.push_back(gfx::Vector2d(345, 0));
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(params.distances[0], scroll_target->start_to_end_distance());
 }
 
 TEST_F(SyntheticGestureControllerTest, SingleScrollGestureMouseDiagonal) {
   CreateControllerAndTarget<MockScrollMouseTarget>();
 
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
-  params.anchor.SetPoint(90, 12);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::MOUSE_WHEEL_INPUT;
+  params.start_point.SetPoint(90, 12);
   params.distances.push_back(gfx::Vector2d(-194, 303));
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(params.distances[0], scroll_target->start_to_end_distance());
 }
 
 TEST_F(SyntheticGestureControllerTest, MultiScrollGestureMouse) {
   CreateControllerAndTarget<MockScrollMouseTarget>();
 
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
-  params.anchor.SetPoint(90, 12);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::MOUSE_WHEEL_INPUT;
+  params.start_point.SetPoint(90, 12);
   params.distances.push_back(gfx::Vector2d(-129, 212));
   params.distances.push_back(gfx::Vector2d(8, -9));
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(params.distances[0] + params.distances[1],
             scroll_target->start_to_end_distance());
 }
 
 TEST_F(SyntheticGestureControllerTest, MultiScrollGestureMouseHorizontal) {
   CreateControllerAndTarget<MockScrollMouseTarget>();
 
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
-  params.anchor.SetPoint(90, 12);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::MOUSE_WHEEL_INPUT;
+  params.start_point.SetPoint(90, 12);
   params.distances.push_back(gfx::Vector2d(-129, 0));
   params.distances.push_back(gfx::Vector2d(79, 0));
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   // This check only works for horizontal or vertical scrolls because of
   // floating point precision issues with diagonal scrolls.
   EXPECT_FLOAT_EQ(params.distances[0].Length() + params.distances[1].Length(),
-                  scroll_target->total_abs_scroll_distance_length());
+                  scroll_target->total_abs_move_distance_length());
   EXPECT_EQ(params.distances[0] + params.distances[1],
             scroll_target->start_to_end_distance());
 }
 
 void CheckIsWithinRangeMulti(float scroll_distance,
                              int target_distance,
                              SyntheticGestureTarget* target) {
   if (target_distance > 0) {
     EXPECT_GE(scroll_distance, target_distance - target->GetTouchSlopInDips());
     EXPECT_LE(scroll_distance, target_distance + target->GetTouchSlopInDips());
   } else {
     EXPECT_LE(scroll_distance, target_distance + target->GetTouchSlopInDips());
     EXPECT_GE(scroll_distance, target_distance - target->GetTouchSlopInDips());
   }
 }
 
 void CheckMultiScrollDistanceIsWithinRange(
     const gfx::Vector2dF& scroll_distance,
-    const gfx::Vector2d& target_distance,
+    const gfx::Vector2dF& target_distance,
     SyntheticGestureTarget* target) {
   CheckIsWithinRangeMulti(scroll_distance.x(), target_distance.x(), target);
   CheckIsWithinRangeMulti(scroll_distance.y(), target_distance.y(), target);
 }
 
 TEST_F(SyntheticGestureControllerTest, MultiScrollGestureTouch) {
-  CreateControllerAndTarget<MockScrollTouchTarget>();
+  CreateControllerAndTarget<MockMoveTouchTarget>();
 
-  SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.anchor.SetPoint(8, -13);
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
+  params.prevent_slop = false;

[picksi, 2015/02/23 12:22:24]

(I haven't looked...) but Does params have a constructor? If so, should
prevent_slop shoild default to false (?true?)? Do you need this value to have
any value here... i.e. is it used internally somewhere? Could it be set in the
same way I've proposed above e.g. params.setSlopFromType( GetParam() );

[ssid, 2015/02/23 14:03:04]

Made changes.

+  params.start_point.SetPoint(8, -13);
   params.distances.push_back(gfx::Vector2d(234, 133));
   params.distances.push_back(gfx::Vector2d(-9, 78));
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   CheckMultiScrollDistanceIsWithinRange(
       scroll_target->start_to_end_distance(),
       params.distances[0] + params.distances[1],
       target_);
 }
 
-TEST_F(SyntheticGestureControllerTest, MultiScrollGestureTouchVertical) {
-  CreateControllerAndTarget<MockScrollTouchTarget>();
+TEST_P(SyntheticGestureControllerTestWithParam,
+       MultiScrollGestureTouchVertical) {
+  CreateControllerAndTarget<MockMoveTouchTarget>();
+
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
+  if (GetParam() == TOUCH_SCROLL) {
+    params.prevent_slop = false;
+  } else {
+    params.prevent_slop = true;
+  }
+  params.start_point.SetPoint(234, -13);
+  params.distances.push_back(gfx::Vector2d(0, 133));
+  params.distances.push_back(gfx::Vector2d(0, 78));
+
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  if (GetParam() == TOUCH_SCROLL) {
+    EXPECT_FLOAT_EQ(params.distances[0].Length() +
+                        params.distances[1].Length() +
+                        target_->GetTouchSlopInDips(),
+                    scroll_target->total_abs_move_distance_length());
+  EXPECT_EQ(AddTouchSlopToVector(params.distances[0] + params.distances[1],
+                                 target_),
+            scroll_target->start_to_end_distance());
+  } else {
+    EXPECT_FLOAT_EQ(params.distances[0].Length() + params.distances[1].Length(),
+                    scroll_target->total_abs_move_distance_length());
+    EXPECT_EQ(params.distances[0] + params.distances[1],
+              scroll_target->start_to_end_distance());
+  }
+}
+INSTANTIATE_TEST_CASE_P(Single,
+                        SyntheticGestureControllerTestWithParam,
+                        testing::Values(TOUCH_SCROLL, TOUCH_DRAG));
+
+TEST_F(SyntheticGestureControllerTest, SingleDragGestureMouseDiagonal) {
+  CreateControllerAndTarget<MockDragMouseTarget>();
+
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::MOUSE_DRAG_INPUT;
+  params.start_point.SetPoint(0, 7);
+  params.distances.push_back(gfx::Vector2d(413, -83));
+
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockMoveGestureTarget* drag_target =
+      static_cast<MockMoveGestureTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(drag_target->start_to_end_distance(), params.distances[0]);
+}
+
+TEST_F(SyntheticGestureControllerTest, SingleDragGestureMouseZeroDistance) {
+  CreateControllerAndTarget<MockDragMouseTarget>();
+
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::MOUSE_DRAG_INPUT;
+  params.start_point.SetPoint(-32, 43);
+  params.distances.push_back(gfx::Vector2d(0, 0));
+
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockMoveGestureTarget* drag_target =
+      static_cast<MockMoveGestureTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(gfx::Vector2dF(0, 0), drag_target->start_to_end_distance());
+}
+
+TEST_F(SyntheticGestureControllerTest, MultiDragGestureMouse) {
+  CreateControllerAndTarget<MockDragMouseTarget>();
+
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::MOUSE_DRAG_INPUT;
+  params.start_point.SetPoint(8, -13);
+  params.distances.push_back(gfx::Vector2d(234, 133));
+  params.distances.push_back(gfx::Vector2d(-9, 78));
+
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockMoveGestureTarget* drag_target =
+      static_cast<MockMoveGestureTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(drag_target->start_to_end_distance(),
+            params.distances[0] + params.distances[1]);
+}
+
+TEST_F(SyntheticGestureControllerTest,
+       SyntheticSmoothDragTestUsingSingleMouseDrag) {
+  CreateControllerAndTarget<MockDragMouseTarget>();
+
+  SyntheticSmoothDragGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
+  params.distances.push_back(gfx::Vector2d(234, 133));
+  params.speed_in_pixels_s = 800;
+
+  scoped_ptr<SyntheticSmoothDragGesture> gesture(
+      new SyntheticSmoothDragGesture(params));
+  const base::TimeTicks timestamp;
+  gesture->ForwardInputEvents(timestamp, target_);
+}
+
+TEST_F(SyntheticGestureControllerTest,
+       SyntheticSmoothDragTestUsingSingleTouchDrag) {
+  CreateControllerAndTarget<MockMoveTouchTarget>();
+
+  SyntheticSmoothDragGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  params.start_point.SetPoint(89, 32);
+  params.distances.push_back(gfx::Vector2d(0, 123));
+  params.speed_in_pixels_s = 800;
+
+  scoped_ptr<SyntheticSmoothDragGesture> gesture(
+      new SyntheticSmoothDragGesture(params));
+  const base::TimeTicks timestamp;
+  gesture->ForwardInputEvents(timestamp, target_);
+}
+
+TEST_F(SyntheticGestureControllerTest,
+       SyntheticSmoothScrollTestUsingSingleTouchScroll) {
+  CreateControllerAndTarget<MockMoveTouchTarget>();
 
   SyntheticSmoothScrollGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.anchor.SetPoint(234, -13);
-  params.distances.push_back(gfx::Vector2d(0, 133));
-  params.distances.push_back(gfx::Vector2d(0, 78));
 
   scoped_ptr<SyntheticSmoothScrollGesture> gesture(
       new SyntheticSmoothScrollGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
-  FlushInputUntilComplete();
+  const base::TimeTicks timestamp;
+  gesture->ForwardInputEvents(timestamp, target_);
+}
 
-  MockScrollGestureTarget* scroll_target =
-      static_cast<MockScrollGestureTarget*>(target_);
-  EXPECT_EQ(1, num_success_);
-  EXPECT_EQ(0, num_failure_);
-  EXPECT_FLOAT_EQ(
-      params.distances[0].Length() + params.distances[1].Length() +
-          target_->GetTouchSlopInDips(),
-      scroll_target->total_abs_scroll_distance_length());
-  EXPECT_EQ(AddTouchSlopToVector(params.distances[0] + params.distances[1],
-                                 target_),
-            scroll_target->start_to_end_distance());
+TEST_F(SyntheticGestureControllerTest,
+       SyntheticSmoothScrollTestUsingSingleMouseScroll) {
+  CreateControllerAndTarget<MockScrollMouseTarget>();
+
+  SyntheticSmoothScrollGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
+  params.anchor.SetPoint(432, 89);
+  params.distances.push_back(gfx::Vector2d(0, -234));
+  params.speed_in_pixels_s = 800;
+
+  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
+      new SyntheticSmoothScrollGesture(params));
+  const base::TimeTicks timestamp;
+  gesture->ForwardInputEvents(timestamp, target_);
 }
 
 TEST_F(SyntheticGestureControllerTest, PinchGestureTouchZoomIn) {
   CreateControllerAndTarget<MockSyntheticPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   params.scale_factor = 2.3f;
   params.anchor.SetPoint(54, 89);
 
@@ skipping 93 matching lines @@
   EXPECT_TRUE(tap_target->GestureFinished());
   EXPECT_EQ(tap_target->position(), params.position);
   EXPECT_EQ(tap_target->GetDuration().InMilliseconds(), params.duration_ms);
   EXPECT_GE(GetTotalTime(),
             base::TimeDelta::FromMilliseconds(params.duration_ms));
 }
 
 }  // namespace
 
 }  // namespace content