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 SyntheticGestureControllerTestUtility {

[Sami, 2015/02/20 17:57:07]

nit: call this SyntheticGestureControllerTestBase to make its relationship to
the other classes clearer.

[ssid, 2015/02/23 11:40:32]

Done.

  public:
-  SyntheticGestureControllerTest() {}
-  ~SyntheticGestureControllerTest() override {}
+  SyntheticGestureControllerTestUtility() {}
+  ~SyntheticGestureControllerTestUtility() {}
 
  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(
+            &SyntheticGestureControllerTestUtility::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 SyntheticGestureControllerTestUtility,
+      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 SyntheticGestureControllerTestUtility,
+      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 106 matching lines @@
 
   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>();
+scoped_ptr<SyntheticSmoothMoveGesture> CreateMoveGestureUsingParams(
+    SyntheticSmoothScrollGestureParams params,

[Sami, 2015/02/20 17:57:07]

This shouldn't take scroll parameters since we're trying to create a move
gesture. Maybe it's a sign that we should add a struct for the move parameters?
Alternatively we could make SyntheticSmoothMoveGesture get constructed
reasonable defaults without any parameters and have setters for overriding the
settings?

[ssid, 2015/02/20 18:48:16]

struct for move parameters sounds better because, we wont be using the get
creator anywhere else apart from tests.

[ssid, 2015/02/23 11:40:32]

Added a class for move gesture params. PTAL.

+    SyntheticSmoothMoveGesture::InputType input_type) {
+  std::vector<gfx::Vector2dF> distances_float;
+  for (uint64 i = 0; i < params.distances.size(); i++)
+    distances_float.push_back(params.distances[i]);
+
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(new SyntheticSmoothMoveGesture(
+      input_type, params.anchor, distances_float, params.speed_in_pixels_s,
+      params.prevent_fling));
+  return gesture;
+}
+
+TEST_P(SyntheticGestureControllerTestWithParam,
+       SingleMoveGestureTouchVertical) {
+  CreateControllerAndTarget<MockMoveTouchTarget>();
 
   SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  SyntheticSmoothMoveGesture::InputType input_type;
+  if (GetParam() == TOUCH_SCROLL) {
+    input_type = SyntheticSmoothMoveGesture::TOUCH_SCROLL_INPUT;
+  } else {
+    input_type = SyntheticSmoothMoveGesture::TOUCH_DRAG_INPUT;
+  }
   params.anchor.SetPoint(89, 32);
   params.distances.push_back(gfx::Vector2d(0, 123));
+  params.speed_in_pixels_s = 800;

[Sami, 2015/02/20 17:57:07]

Why this change?

[ssid, 2015/02/20 18:48:16]

Some tests were failing because this wasn't set and it takes junk value, in some
platforms. The default value will not get set because it takes the junk value.
The default value is set in gpu_benchmarking_extension.cc .

 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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());

[picksi, 2015/02/20 16:34:11]

Calling this 'distance' and the param 'distances' is confusing as distance is a
scalar value, whereas these values are vectors. If it doesn't require too much
refactoring it is probably worth fixing this.

+  } else {
+    EXPECT_EQ(params.distances[0], scroll_target->start_to_end_distance());
+  }
 }
+INSTANTIATE_TEST_CASE_P(Single,
+                        SyntheticGestureControllerTestWithParam,
+                        testing::Values(TOUCH_SCROLL, TOUCH_DRAG));
 
-TEST_F(SyntheticGestureControllerTest, SingleScrollGestureTouchHorizontal) {
-  CreateControllerAndTarget<MockScrollTouchTarget>();
+TEST_P(SyntheticGestureControllerTestWithParam,
+       SingleScrollGestureTouchHorizontal) {
+  CreateControllerAndTarget<MockMoveTouchTarget>();
 
   SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  SyntheticSmoothMoveGesture::InputType input_type;
+  if (GetParam() == TOUCH_SCROLL) {
+    input_type = SyntheticSmoothMoveGesture::TOUCH_SCROLL_INPUT;
+  } else {
+    input_type = SyntheticSmoothMoveGesture::TOUCH_DRAG_INPUT;
+  }
   params.anchor.SetPoint(12, -23);
   params.distances.push_back(gfx::Vector2d(-234, 0));
+  params.speed_in_pixels_s = 800;
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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_);
+  if (GetParam() == TOUCH_SCROLL) {
   EXPECT_EQ(AddTouchSlopToVector(params.distances[0], target_),

[Sami, 2015/02/20 17:57:06]

Indenting seems off here. "git cl format" should fix this for you automatically
(or were you avoiding it to reduce the changes?)

[ssid, 2015/02/20 18:48:16]

Git cl format didn't fix this because no change=! changing manually. Will
recheck.

             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,
     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;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::TOUCH_SCROLL_INPUT;
   params.anchor.SetPoint(0, 7);
   params.distances.push_back(gfx::Vector2d(413, -83));
+  params.speed_in_pixels_s = 800;
 

[picksi, 2015/02/20 16:34:11]

The vertical, horizontal, diagonal and zero tests are all identical apart from
the vector that is used. Can we refactor out the common code into a function and
call it with different vectors as parameters?

-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::TOUCH_SCROLL_INPUT;
   params.anchor.SetPoint(-98, -23);
   params.distances.push_back(gfx::Vector2d(21, -12));
   params.prevent_fling = true;
+  params.speed_in_pixels_s = 800;
 
   target_->set_pointer_assumed_stopped_time_ms(543);
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::TOUCH_SCROLL_INPUT;
   params.anchor.SetPoint(-89, 78);
   params.distances.push_back(gfx::Vector2d(-43, 19));
   params.prevent_fling = false;
+  params.speed_in_pixels_s = 800;
 
   target_->set_pointer_assumed_stopped_time_ms(543);
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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;
+  SyntheticSmoothMoveGesture::InputType input_type;
+  if (GetParam() == TOUCH_SCROLL) {
+    input_type = SyntheticSmoothMoveGesture::TOUCH_SCROLL_INPUT;
+  } else {
+    input_type = SyntheticSmoothMoveGesture::TOUCH_DRAG_INPUT;
+  }
   params.anchor.SetPoint(-32, 43);
   params.distances.push_back(gfx::Vector2d(0, 0));
+  params.speed_in_pixels_s = 800;
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::MOUSE_WHEEL_INPUT;
   params.anchor.SetPoint(432, 89);
   params.distances.push_back(gfx::Vector2d(0, -234));
+  params.speed_in_pixels_s = 800;
 

[picksi, 2015/02/20 16:34:10]

Could this function be part of the other tests by using MOUSE_WHEEL_INPUT as an
input type in the same way as TOUCH_SCROLL_DRAG and TOUCH_DRAG_INPUT?

[ssid, 2015/02/23 11:40:32]

I think there is very less common code for this to be done, and it might make
the test debugging difficult if tests are merged.

-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::MOUSE_WHEEL_INPUT;
   params.anchor.SetPoint(90, 12);
   params.distances.push_back(gfx::Vector2d(345, 0));
+  params.speed_in_pixels_s = 800;
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::MOUSE_WHEEL_INPUT;
   params.anchor.SetPoint(90, 12);
   params.distances.push_back(gfx::Vector2d(-194, 303));
+  params.speed_in_pixels_s = 800;
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::MOUSE_WHEEL_INPUT;
   params.anchor.SetPoint(90, 12);
   params.distances.push_back(gfx::Vector2d(-129, 212));
   params.distances.push_back(gfx::Vector2d(8, -9));
+  params.speed_in_pixels_s = 800;
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::MOUSE_WHEEL_INPUT;
   params.anchor.SetPoint(90, 12);
   params.distances.push_back(gfx::Vector2d(-129, 0));
   params.distances.push_back(gfx::Vector2d(79, 0));
+  params.speed_in_pixels_s = 800;
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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());

[picksi, 2015/02/20 16:34:10]

The MOUSE_WHEEL_INPUT types are all identical too, apart from the vector(s)
used... It seems like it should be possible to do something like:

SyntheticSmoothScrollGestureParams params;
params.distances.push_back(gfx::Vector2d(-129, 0));  
params.distances.push_back(gfx::Vector2d(79, 0));
CheckGesture(params, MOUSE_WHEEL_INPUT, gfx::Vector2d(-129,
0)+gfx::Vector2d(-129, 0));

Instead of all the duplicated boiler-plate code.

[ssid, 2015/02/23 11:40:32]

The change in test structure can be kept for next CL I think.

 }
 
 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,
     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;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::TOUCH_SCROLL_INPUT;
   params.anchor.SetPoint(8, -13);
   params.distances.push_back(gfx::Vector2d(234, 133));
   params.distances.push_back(gfx::Vector2d(-9, 78));
+  params.speed_in_pixels_s = 800;
 
-  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
-      new SyntheticSmoothScrollGesture(params));
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
   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>();
 
   SyntheticSmoothScrollGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  SyntheticSmoothMoveGesture::InputType input_type;
+  if (GetParam() == TOUCH_SCROLL) {
+    input_type = SyntheticSmoothMoveGesture::TOUCH_SCROLL_INPUT;
+  } else {
+    input_type = SyntheticSmoothMoveGesture::TOUCH_DRAG_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();
-
-  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());
+  params.speed_in_pixels_s = 800;
+
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
+  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());
+  }
+}
+
+scoped_ptr<SyntheticSmoothMoveGesture> CreateMoveGestureUsingParams(
+    SyntheticSmoothDragGestureParams params,
+    SyntheticSmoothMoveGesture::InputType input_type) {
+  bool prevent_fling = true;
+
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture(new SyntheticSmoothMoveGesture(
+      input_type, params.start_point, params.distances,
+      params.speed_in_pixels_s, prevent_fling));
+  return gesture;
+}
+
+TEST_F(SyntheticGestureControllerTest, SingleDragGestureMouseDiagonal) {
+  CreateControllerAndTarget<MockDragMouseTarget>();
+
+  SyntheticSmoothDragGestureParams params;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::MOUSE_DRAG_INPUT;
+  params.start_point.SetPoint(0, 7);
+  params.distances.push_back(gfx::Vector2d(413, -83));
+  params.speed_in_pixels_s = 800;
+

[picksi, 2015/02/20 16:34:11]

Aren't these MOUSE_DRAG_INPUT tests the same as the other input styles? Can we
use common tests and pass MOUSE_DRAG_INPUT as a parameter?

[Sami, 2015/02/20 17:57:07]

Yeah, this is starting to look like too much duplication. Either we find a way
to only test what SyntheticSmooth{Drag,Scroll}Gesture are doing (i.e.,
configuring the move gesture correctly) or we find a way to parameterize the
tests so that we can test SyntheticSmooth({Drag,Scroll,Move} using the same
tests. Any ideas?

[ssid, 2015/02/20 18:48:16]

I will reduce the last 4 tests to just check if type is correct, and remove the
single drag test. This will reduce lot of code duplication here. I think the
clean up of the functions can me pushed to next CL.

+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
+  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>();
+
+  SyntheticSmoothDragGestureParams params;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::MOUSE_DRAG_INPUT;
+  params.start_point.SetPoint(-32, 43);
+  params.distances.push_back(gfx::Vector2d(0, 0));
+  params.speed_in_pixels_s = 800;
+
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
+  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>();
+
+  SyntheticSmoothDragGestureParams params;
+  SyntheticSmoothMoveGesture::InputType input_type =
+      SyntheticSmoothMoveGesture::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));
+  params.speed_in_pixels_s = 800;
+
+  scoped_ptr<SyntheticSmoothMoveGesture> gesture =
+      CreateMoveGestureUsingParams(params, input_type);
+  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,
+       SingleDragGestureMouseUsingDragGestureObject) {

[Sami, 2015/02/20 17:57:07]

I'm not sure what the name of this test means.

[ssid, 2015/02/23 11:40:32]

Changed the names.

+  CreateControllerAndTarget<MockDragMouseTarget>();
+
+  SyntheticSmoothDragGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::MOUSE_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));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockMoveGestureTarget* drag_target =
+      static_cast<MockMoveGestureTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(params.distances[0], drag_target->start_to_end_distance());
+}
+
+TEST_F(SyntheticGestureControllerTest,
+       SingleMoveGestureTouchVerticalUsingScrollObject) {
+  CreateControllerAndTarget<MockMoveTouchTarget>();
+
+  SyntheticSmoothScrollGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  params.anchor.SetPoint(89, 32);
+  params.distances.push_back(gfx::Vector2d(0, 123));
+  params.speed_in_pixels_s = 800;
+
+  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
+      new SyntheticSmoothScrollGesture(params));
+
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  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());
+}
+
+TEST_F(SyntheticGestureControllerTest,
+       SingleMoveGestureTouchVerticalUsingDragObject) {
+  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));
+
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  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,
+       SingleScrollGestureMouseVerticalUsingScrollObject) {
+  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));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  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, 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