Use std::move() instead of .Pass() in remoting/host

remoting/host/touch_injector_win_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/touch_injector_win.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <utility>
 
 #include "base/stl_util.h"
 #include "remoting/proto/event.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::InSequence;
 using ::testing::ExpectationSet;
@@ skipping 111 matching lines @@
       InjectTouchInput(1, EqualsSinglePointerTouchInfo(expected_touch_info)))
       .WillOnce(Return(1));
 
   expected_touch_info.pressure = 0;  // Min
   EXPECT_CALL(
       *delegate_mock,
       InjectTouchInput(1, EqualsSinglePointerTouchInfo(expected_touch_info)))
       .WillOnce(Return(1));
 
   TouchInjectorWin injector;
-  injector.SetInjectorDelegateForTest(delegate_mock.Pass());
+  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
   EXPECT_TRUE(injector.Init());
   injector.InjectTouchEvent(event);
 
   // Change to MOVE so that there still only one point.
   event.set_event_type(TouchEvent::TOUCH_POINT_MOVE);
   point->set_pressure(2.0f);
   injector.InjectTouchEvent(event);
 
   point->set_pressure(-3.0f);
   injector.InjectTouchEvent(event);
@@ skipping 33 matching lines @@
 
   InSequence s;
   EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
       .WillOnce(Return(1));
   EXPECT_CALL(
       *delegate_mock,
       InjectTouchInput(1, EqualsSinglePointerTouchInfo(expected_touch_info)))
       .WillOnce(Return(1));
 
   TouchInjectorWin injector;
-  injector.SetInjectorDelegateForTest(delegate_mock.Pass());
+  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
   EXPECT_TRUE(injector.Init());
   injector.InjectTouchEvent(event);
 }
 
 // If initialization fails, it should not call any touch injection functions.
 TEST(TouchInjectorWinTest, InitFailed) {
   scoped_ptr<TouchInjectorWinDelegateMock> delegate_mock(
       new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
 
   TouchEvent event;
   event.set_event_type(TouchEvent::TOUCH_POINT_START);
 
   InSequence s;
   EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
       .WillOnce(Return(0));
   EXPECT_CALL(*delegate_mock, InjectTouchInput(_, _)).Times(0);
 
   TouchInjectorWin injector;
-  injector.SetInjectorDelegateForTest(delegate_mock.Pass());
+  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
   EXPECT_FALSE(injector.Init());
   injector.InjectTouchEvent(event);
 }
 
 // Deinitialize and initialize should clean the state.
 TEST(TouchInjectorWinTest, Reinitialize) {
   scoped_ptr<TouchInjectorWinDelegateMock> delegate_mock_before_deinitialize(
       new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
   scoped_ptr<TouchInjectorWinDelegateMock> delegate_mock_after_deinitialize(
       new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
@@ skipping 25 matching lines @@
   // After deinitializing and then initializing, previous touch points should be
   // gone.
   id_to_flags.clear();
   id_to_flags[1u] = kStartFlag;
   EXPECT_CALL(
       *delegate_mock_after_deinitialize,
       InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
       .WillOnce(Return(1));
 
   TouchInjectorWin injector;
-  injector.SetInjectorDelegateForTest(delegate_mock_before_deinitialize.Pass());
+  injector.SetInjectorDelegateForTest(
+      std::move(delegate_mock_before_deinitialize));
 
   EXPECT_TRUE(injector.Init());
   injector.InjectTouchEvent(first_event);
   injector.Deinitialize();
 
-  injector.SetInjectorDelegateForTest(delegate_mock_after_deinitialize.Pass());
+  injector.SetInjectorDelegateForTest(
+      std::move(delegate_mock_after_deinitialize));
   EXPECT_TRUE(injector.Init());
   injector.InjectTouchEvent(second_event);
 }
 
 // Make sure that the flag is set to kStartFlag.
 TEST(TouchInjectorWinTest, StartTouchPoint) {
   scoped_ptr<TouchInjectorWinDelegateMock> delegate_mock(
       new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
 
   TouchEvent event;
   event.set_event_type(TouchEvent::TOUCH_POINT_START);
   TouchEventPoint* point = event.add_touch_points();
   point->set_id(0u);
 
   InSequence s;
   EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
       .WillOnce(Return(1));
 
   IdFlagMap id_to_flags;
   id_to_flags[0u] = kStartFlag;
   EXPECT_CALL(
       *delegate_mock,
       InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
       .WillOnce(Return(1));
 
   TouchInjectorWin injector;
-  injector.SetInjectorDelegateForTest(delegate_mock.Pass());
+  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
   EXPECT_TRUE(injector.Init());
   injector.InjectTouchEvent(event);
 }
 
 // Start a point and then move, make sure the flag is set to kMoveFlag.
 TEST(TouchInjectorWinTest, MoveTouchPoint) {
   scoped_ptr<TouchInjectorWinDelegateMock> delegate_mock(
       new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
 
   TouchEvent event;
@@ skipping 13 matching lines @@
       InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
       .WillOnce(Return(1));
 
   id_to_flags[0u] = kMoveFlag;
   EXPECT_CALL(
       *delegate_mock,
       InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
       .WillOnce(Return(1));
 
   TouchInjectorWin injector;
-  injector.SetInjectorDelegateForTest(delegate_mock.Pass());
+  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
   EXPECT_TRUE(injector.Init());
   injector.InjectTouchEvent(event);
   event.set_event_type(TouchEvent::TOUCH_POINT_MOVE);
   injector.InjectTouchEvent(event);
 }
 
 // Start a point and then move, make sure the flag is set to kEndFlag.
 TEST(TouchInjectorWinTest, EndTouchPoint) {
   scoped_ptr<TouchInjectorWinDelegateMock> delegate_mock(
       new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
@@ skipping 14 matching lines @@
       InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
       .WillOnce(Return(1));
 
   id_to_flags[0u] = kEndFlag;
   EXPECT_CALL(
       *delegate_mock,
       InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
       .WillOnce(Return(1));
 
   TouchInjectorWin injector;
-  injector.SetInjectorDelegateForTest(delegate_mock.Pass());
+  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
   EXPECT_TRUE(injector.Init());
   injector.InjectTouchEvent(event);
   event.set_event_type(TouchEvent::TOUCH_POINT_END);
   injector.InjectTouchEvent(event);
 }
 
 // Start a point and then move, make sure the flag is set to kCancelFlag.
 TEST(TouchInjectorWinTest, CancelTouchPoint) {
   scoped_ptr<TouchInjectorWinDelegateMock> delegate_mock(
       new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
@@ skipping 14 matching lines @@
       InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
       .WillOnce(Return(1));
 
   id_to_flags[0u] = kCancelFlag;
   EXPECT_CALL(
       *delegate_mock,
       InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
       .WillOnce(Return(1));
 
   TouchInjectorWin injector;
-  injector.SetInjectorDelegateForTest(delegate_mock.Pass());
+  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
   EXPECT_TRUE(injector.Init());
   injector.InjectTouchEvent(event);
   event.set_event_type(TouchEvent::TOUCH_POINT_CANCEL);
   injector.InjectTouchEvent(event);
 }
 
 // Note that points that haven't changed should be injected as MOVE.
 // This tests:
 // 1. Start first touch point.
 // 2. Start second touch point.
@@ skipping 48 matching lines @@
 
   id_to_flags.erase(1u);
   id_to_flags[0u] = kCancelFlag;
   id_to_flags[2u] = kCancelFlag;
   EXPECT_CALL(
       *delegate_mock,
       InjectTouchInput(2, EqualsPointerTouchInfoFlag(id_to_flags)))
       .WillOnce(Return(1));
 
   TouchInjectorWin injector;
-  injector.SetInjectorDelegateForTest(delegate_mock.Pass());
+  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
   EXPECT_TRUE(injector.Init());
 
   // Start first touch point.
   TouchEvent first_touch_start;
   first_touch_start.set_event_type(TouchEvent::TOUCH_POINT_START);
   TouchEventPoint* point0 = first_touch_start.add_touch_points();
   point0->set_id(0u);
   injector.InjectTouchEvent(first_touch_start);
 
   // Add second touch point.
@@ skipping 30 matching lines @@
   TouchEvent cancel_rest;
   cancel_rest.set_event_type(TouchEvent::TOUCH_POINT_CANCEL);
   point0 = cancel_rest.add_touch_points();
   point0->set_id(0u);
   point2 = cancel_rest.add_touch_points();
   point2->set_id(2u);
   injector.InjectTouchEvent(cancel_rest);
 }
 
 }  // namespace remoting