Convert Pass()→std::move() in //content/browser

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 "content/browser/renderer_host/input/synthetic_gesture_controller.h"
+
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #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_pointer_action.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/input/synthetic_touch_pointer.h"
 #include "content/browser/renderer_host/input/synthetic_touchpad_pinch_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_touchscreen_pinch_gesture.h"
@@ skipping 493 matching lines @@
  protected:
   template<typename MockGestureTarget>
   void CreateControllerAndTarget() {
     target_ = new MockGestureTarget();
     controller_.reset(new SyntheticGestureController(
         scoped_ptr<SyntheticGestureTarget>(target_)));
   }
 
   void QueueSyntheticGesture(scoped_ptr<SyntheticGesture> gesture) {
     controller_->QueueSyntheticGesture(
-        gesture.Pass(),
+        std::move(gesture),
         base::Bind(
             &SyntheticGestureControllerTestBase::OnSyntheticGestureCompleted,
             base::Unretained(this)));
   }
 
   void FlushInputUntilComplete() {
     while (target_->flush_requested()) {
       while (target_->flush_requested()) {
         target_->ClearFlushRequest();
         time_ += base::TimeDelta::FromMilliseconds(kFlushInputRateInMs);
@@ skipping 56 matching lines @@
     time_ = base::TimeTicks();
   }
 };
 
 TEST_F(SyntheticGestureControllerTest, SingleGesture) {
   CreateControllerAndTarget<MockSyntheticGestureTarget>();
 
   bool finished = false;
   scoped_ptr<MockSyntheticGesture> gesture(
       new MockSyntheticGesture(&finished, 3));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   EXPECT_TRUE(finished);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
 }
 
 TEST_F(SyntheticGestureControllerTest, GestureFailed) {
   CreateControllerAndTarget<MockSyntheticGestureTarget>();
 
   bool finished = false;
   scoped_ptr<MockSyntheticGesture> gesture(
       new MockSyntheticGesture(&finished, 0));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   EXPECT_TRUE(finished);
   EXPECT_EQ(1, num_failure_);
   EXPECT_EQ(0, num_success_);
 }
 
 TEST_F(SyntheticGestureControllerTest, SuccessiveGestures) {
   CreateControllerAndTarget<MockSyntheticGestureTarget>();
 
   bool finished_1 = false;
   scoped_ptr<MockSyntheticGesture> gesture_1(
       new MockSyntheticGesture(&finished_1, 2));
   bool finished_2 = false;
   scoped_ptr<MockSyntheticGesture> gesture_2(
       new MockSyntheticGesture(&finished_2, 4));
 
   // Queue first gesture and wait for it to finish
-  QueueSyntheticGesture(gesture_1.Pass());
+  QueueSyntheticGesture(std::move(gesture_1));
   FlushInputUntilComplete();
 
   EXPECT_TRUE(finished_1);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
 
   // Queue second gesture.
-  QueueSyntheticGesture(gesture_2.Pass());
+  QueueSyntheticGesture(std::move(gesture_2));
   FlushInputUntilComplete();
 
   EXPECT_TRUE(finished_2);
   EXPECT_EQ(2, num_success_);
   EXPECT_EQ(0, num_failure_);
 }
 
 TEST_F(SyntheticGestureControllerTest, TwoGesturesInFlight) {
   CreateControllerAndTarget<MockSyntheticGestureTarget>();
 
   bool finished_1 = false;
   scoped_ptr<MockSyntheticGesture> gesture_1(
       new MockSyntheticGesture(&finished_1, 2));
   bool finished_2 = false;
   scoped_ptr<MockSyntheticGesture> gesture_2(
       new MockSyntheticGesture(&finished_2, 4));
 
-  QueueSyntheticGesture(gesture_1.Pass());
-  QueueSyntheticGesture(gesture_2.Pass());
+  QueueSyntheticGesture(std::move(gesture_1));
+  QueueSyntheticGesture(std::move(gesture_2));
   FlushInputUntilComplete();
 
   EXPECT_TRUE(finished_1);
   EXPECT_TRUE(finished_2);
 
   EXPECT_EQ(2, num_success_);
   EXPECT_EQ(0, num_failure_);
 }
 
 TEST_F(SyntheticGestureControllerTest, GestureCompletedOnDidFlushInput) {
   CreateControllerAndTarget<MockSyntheticGestureTarget>();
 
   bool finished_1, finished_2;
   scoped_ptr<MockSyntheticGesture> gesture_1(
       new MockSyntheticGesture(&finished_1, 2));
   scoped_ptr<MockSyntheticGesture> gesture_2(
       new MockSyntheticGesture(&finished_2, 4));
 
-  QueueSyntheticGesture(gesture_1.Pass());
-  QueueSyntheticGesture(gesture_2.Pass());
+  QueueSyntheticGesture(std::move(gesture_1));
+  QueueSyntheticGesture(std::move(gesture_2));
 
   while (target_->flush_requested()) {
     target_->ClearFlushRequest();
     time_ += base::TimeDelta::FromMilliseconds(kFlushInputRateInMs);
     controller_->Flush(time_);
   }
   EXPECT_EQ(0, num_success_);
   controller_->OnDidFlushInput();
   EXPECT_EQ(1, num_success_);
 
@@ skipping 33 matching lines @@
   SyntheticSmoothMoveGestureParams params;
   params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
   if (GetParam() == TOUCH_DRAG) {
     params.add_slop = false;
   }
   params.start_point.SetPoint(89, 32);
   params.distances.push_back(gfx::Vector2d(0, 123));
 
   scoped_ptr<SyntheticSmoothMoveGesture> gesture(
       new SyntheticSmoothMoveGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   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_),
               scroll_target->start_to_end_distance());
   } else {
     EXPECT_EQ(params.distances[0], scroll_target->start_to_end_distance());
   }
 }
 
 TEST_P(SyntheticGestureControllerTestWithParam,
        SingleScrollGestureTouchHorizontal) {
   CreateControllerAndTarget<MockMoveTouchTarget>();
 
   SyntheticSmoothMoveGestureParams params;
   params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
   if (GetParam() == TOUCH_DRAG) {
     params.add_slop = false;
   }
   params.start_point.SetPoint(12, -23);
   params.distances.push_back(gfx::Vector2d(-234, 0));
 
   scoped_ptr<SyntheticSmoothMoveGesture> gesture(
       new SyntheticSmoothMoveGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   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_),
               scroll_target->start_to_end_distance());
   } else {
@@ skipping 24 matching lines @@
 TEST_F(SyntheticGestureControllerTest, SingleScrollGestureTouchDiagonal) {
   CreateControllerAndTarget<MockMoveTouchTarget>();
 
   SyntheticSmoothMoveGestureParams params;
   params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_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());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   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<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.
   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<SyntheticSmoothMoveGesture> gesture(
       new SyntheticSmoothMoveGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   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<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.
   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<SyntheticSmoothMoveGesture> gesture(
       new SyntheticSmoothMoveGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   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_P(SyntheticGestureControllerTestWithParam,
        SingleScrollGestureTouchZeroDistance) {
   CreateControllerAndTarget<MockMoveTouchTarget>();
 
   SyntheticSmoothMoveGestureParams params;
   params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
   if (GetParam() == TOUCH_DRAG) {
     params.add_slop = false;
   }
   params.start_point.SetPoint(-32, 43);
   params.distances.push_back(gfx::Vector2d(0, 0));
 
   scoped_ptr<SyntheticSmoothMoveGesture> gesture(
       new SyntheticSmoothMoveGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   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>();
 
   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<SyntheticSmoothMoveGesture> gesture(
       new SyntheticSmoothMoveGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   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, SingleScrollGestureMouseHorizontal) {
   CreateControllerAndTarget<MockScrollMouseTarget>();
 
   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<SyntheticSmoothMoveGesture> gesture(
       new SyntheticSmoothMoveGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   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, SingleScrollGestureMouseDiagonal) {
   CreateControllerAndTarget<MockScrollMouseTarget>();
 
   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<SyntheticSmoothMoveGesture> gesture(
       new SyntheticSmoothMoveGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   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, MultiScrollGestureMouse) {
   CreateControllerAndTarget<MockScrollMouseTarget>();
 
   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<SyntheticSmoothMoveGesture> gesture(
       new SyntheticSmoothMoveGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   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>();
 
   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<SyntheticSmoothMoveGesture> gesture(
       new SyntheticSmoothMoveGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   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_move_distance_length());
@@ skipping 25 matching lines @@
   CreateControllerAndTarget<MockMoveTouchTarget>();
 
   SyntheticSmoothMoveGestureParams params;
   params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_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());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   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_P(SyntheticGestureControllerTestWithParam,
        MultiScrollGestureTouchVertical) {
   CreateControllerAndTarget<MockMoveTouchTarget>();
 
   SyntheticSmoothMoveGestureParams params;
   params.input_type = SyntheticSmoothMoveGestureParams::TOUCH_INPUT;
   if (GetParam() == TOUCH_DRAG) {
     params.add_slop = false;
   }
   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());
+  QueueSyntheticGesture(std::move(gesture));
   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(),
@@ skipping 16 matching lines @@
 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());
+  QueueSyntheticGesture(std::move(gesture));
   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());
+  QueueSyntheticGesture(std::move(gesture));
   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());
+  QueueSyntheticGesture(std::move(gesture));
   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]);
 }
 
@@ skipping 61 matching lines @@
        TouchscreenTouchpadPinchGestureTouchZoomIn) {
   CreateControllerAndTarget<MockSyntheticTouchscreenPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   params.scale_factor = 2.3f;
   params.anchor.SetPoint(54, 89);
 
   scoped_ptr<SyntheticTouchscreenPinchGesture> gesture(
       new SyntheticTouchscreenPinchGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   MockSyntheticTouchscreenPinchTouchTarget* pinch_target =
       static_cast<MockSyntheticTouchscreenPinchTouchTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pinch_target->zoom_direction(),
             MockSyntheticTouchscreenPinchTouchTarget::ZOOM_IN);
   EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
 }
 
 TEST_F(SyntheticGestureControllerTest,
        TouchscreenTouchpadPinchGestureTouchZoomOut) {
   CreateControllerAndTarget<MockSyntheticTouchscreenPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   params.scale_factor = 0.4f;
   params.anchor.SetPoint(-12, 93);
 
   scoped_ptr<SyntheticTouchscreenPinchGesture> gesture(
       new SyntheticTouchscreenPinchGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   MockSyntheticTouchscreenPinchTouchTarget* pinch_target =
       static_cast<MockSyntheticTouchscreenPinchTouchTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pinch_target->zoom_direction(),
             MockSyntheticTouchscreenPinchTouchTarget::ZOOM_OUT);
   EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
 }
 
 TEST_F(SyntheticGestureControllerTest,
        TouchscreenTouchpadPinchGestureTouchNoScaling) {
   CreateControllerAndTarget<MockSyntheticTouchscreenPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   params.scale_factor = 1.0f;
 
   scoped_ptr<SyntheticTouchscreenPinchGesture> gesture(
       new SyntheticTouchscreenPinchGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   MockSyntheticTouchscreenPinchTouchTarget* pinch_target =
       static_cast<MockSyntheticTouchscreenPinchTouchTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pinch_target->zoom_direction(),
             MockSyntheticTouchscreenPinchTouchTarget::ZOOM_DIRECTION_UNKNOWN);
   EXPECT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
 }
 
 TEST_F(SyntheticGestureControllerTest, TouchpadPinchGestureTouchZoomIn) {
   CreateControllerAndTarget<MockSyntheticTouchpadPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
   params.scale_factor = 2.3f;
   params.anchor.SetPoint(54, 89);
 
   scoped_ptr<SyntheticTouchpadPinchGesture> gesture(
       new SyntheticTouchpadPinchGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   MockSyntheticTouchpadPinchTouchTarget* pinch_target =
       static_cast<MockSyntheticTouchpadPinchTouchTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pinch_target->zoom_direction(),
             MockSyntheticTouchpadPinchTouchTarget::ZOOM_IN);
   EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->scale_factor());
 }
 
 TEST_F(SyntheticGestureControllerTest, TouchpadPinchGestureTouchZoomOut) {
   CreateControllerAndTarget<MockSyntheticTouchpadPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
   params.scale_factor = 0.4f;
   params.anchor.SetPoint(-12, 93);
 
   scoped_ptr<SyntheticTouchpadPinchGesture> gesture(
       new SyntheticTouchpadPinchGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   MockSyntheticTouchpadPinchTouchTarget* pinch_target =
       static_cast<MockSyntheticTouchpadPinchTouchTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pinch_target->zoom_direction(),
             MockSyntheticTouchpadPinchTouchTarget::ZOOM_OUT);
   EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->scale_factor());
 }
 
 TEST_F(SyntheticGestureControllerTest, TouchpadPinchGestureTouchNoScaling) {
   CreateControllerAndTarget<MockSyntheticTouchpadPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
   params.scale_factor = 1.0f;
 
   scoped_ptr<SyntheticTouchpadPinchGesture> gesture(
       new SyntheticTouchpadPinchGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   MockSyntheticTouchpadPinchTouchTarget* pinch_target =
       static_cast<MockSyntheticTouchpadPinchTouchTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pinch_target->zoom_direction(),
             MockSyntheticTouchpadPinchTouchTarget::ZOOM_DIRECTION_UNKNOWN);
   EXPECT_EQ(params.scale_factor, pinch_target->scale_factor());
 }
 
 // Ensure that if SyntheticPinchGesture is instantiated with TOUCH_INPUT it
 // correctly creates a touchscreen gesture.
 TEST_F(SyntheticGestureControllerTest, PinchGestureExplicitTouch) {
   CreateControllerAndTarget<MockSyntheticTouchscreenPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   params.scale_factor = 2.3f;
   params.anchor.SetPoint(54, 89);
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   // Gesture target will fail expectations if the wrong underlying
   // SyntheticPinch*Gesture was instantiated.
 }
 
 // Ensure that if SyntheticPinchGesture is instantiated with MOUSE_INPUT it
 // correctly creates a touchpad gesture.
 TEST_F(SyntheticGestureControllerTest, PinchGestureExplicitMouse) {
   CreateControllerAndTarget<MockSyntheticTouchpadPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
   params.scale_factor = 2.3f;
   params.anchor.SetPoint(54, 89);
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   // Gesture target will fail expectations if the wrong underlying
   // SyntheticPinch*Gesture was instantiated.
 }
 
 // Ensure that if SyntheticPinchGesture is instantiated with DEFAULT_INPUT it
 // correctly creates a touchscreen gesture for a touchscreen controller.
 TEST_F(SyntheticGestureControllerTest, PinchGestureDefaultTouch) {
   CreateControllerAndTarget<MockSyntheticTouchscreenPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
   params.scale_factor = 2.3f;
   params.anchor.SetPoint(54, 89);
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   // Gesture target will fail expectations if the wrong underlying
   // SyntheticPinch*Gesture was instantiated.
 }
 
 // Ensure that if SyntheticPinchGesture is instantiated with DEFAULT_INPUT it
 // correctly creates a touchpad gesture for a touchpad controller.
 TEST_F(SyntheticGestureControllerTest, PinchGestureDefaultMouse) {
   CreateControllerAndTarget<MockSyntheticTouchpadPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
   params.scale_factor = 2.3f;
   params.anchor.SetPoint(54, 89);
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   // Gesture target will fail expectations if the wrong underlying
   // SyntheticPinch*Gesture was instantiated.
 }
 
 TEST_F(SyntheticGestureControllerTest, TapGestureTouch) {
   CreateControllerAndTarget<MockSyntheticTapTouchTarget>();
 
   SyntheticTapGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   params.duration_ms = 123;
   params.position.SetPoint(87, -124);
 
   scoped_ptr<SyntheticTapGesture> gesture(new SyntheticTapGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   MockSyntheticTapTouchTarget* tap_target =
       static_cast<MockSyntheticTapTouchTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   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));
 }
 
 TEST_F(SyntheticGestureControllerTest, TapGestureMouse) {
   CreateControllerAndTarget<MockSyntheticTapMouseTarget>();
 
   SyntheticTapGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
   params.duration_ms = 79;
   params.position.SetPoint(98, 123);
 
   scoped_ptr<SyntheticTapGesture> gesture(new SyntheticTapGesture(params));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   MockSyntheticTapMouseTarget* tap_target =
       static_cast<MockSyntheticTapMouseTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   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));
 }
 
 TEST_F(SyntheticGestureControllerTest, PointerTouchAction) {
   CreateControllerAndTarget<MockSyntheticPointerTouchActionTarget>();
 
   SyntheticTouchPointer synthetic_pointer;
 
   gfx::PointF position(54, 89);
   scoped_ptr<SyntheticPointerAction> gesture(new SyntheticPointerAction(
       SyntheticGestureParams::TOUCH_INPUT, SyntheticGesture::PRESS,
       &synthetic_pointer, position));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   MockSyntheticPointerTouchActionTarget* pointer_touch_target =
       static_cast<MockSyntheticPointerTouchActionTarget*>(target_);
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchStart);
   EXPECT_EQ(pointer_touch_target->positions(0), position);
   EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StatePressed);
   ASSERT_EQ(pointer_touch_target->touch_length(), 1U);
 
   position.SetPoint(79, 132);
   gesture.reset(new SyntheticPointerAction(SyntheticGestureParams::TOUCH_INPUT,
                                            SyntheticGesture::PRESS,
                                            &synthetic_pointer, position));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   pointer_touch_target =
       static_cast<MockSyntheticPointerTouchActionTarget*>(target_);
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchStart);
   EXPECT_EQ(pointer_touch_target->indexes(1), 1);
   EXPECT_EQ(pointer_touch_target->positions(1), position);
   EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StatePressed);
   ASSERT_EQ(pointer_touch_target->touch_length(), 2U);
 
   int index = 1;
   position.SetPoint(133, 156);
   gesture.reset(new SyntheticPointerAction(
       SyntheticGestureParams::TOUCH_INPUT, SyntheticGesture::MOVE,
       &synthetic_pointer, position, index));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   pointer_touch_target =
       static_cast<MockSyntheticPointerTouchActionTarget*>(target_);
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchMove);
   EXPECT_EQ(pointer_touch_target->positions(1), position);
   EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StateMoved);
   ASSERT_EQ(pointer_touch_target->touch_length(), 2U);
 
   gesture.reset(new SyntheticPointerAction(
       SyntheticGestureParams::TOUCH_INPUT, SyntheticGesture::RELEASE,
       &synthetic_pointer, position, index));
-  QueueSyntheticGesture(gesture.Pass());
+  QueueSyntheticGesture(std::move(gesture));
   FlushInputUntilComplete();
 
   pointer_touch_target =
       static_cast<MockSyntheticPointerTouchActionTarget*>(target_);
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchEnd);
   EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StateReleased);
 }
 
 }  // namespace
 
 }  // namespace content