Convert //remoting to use std::unique_ptr

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>
@@ skipping 70 matching lines @@
   MOCK_METHOD2(InitializeTouchInjection, BOOL(UINT32 max_count, DWORD dw_mode));
   MOCK_METHOD2(InjectTouchInput,
                DWORD(UINT32 count, const POINTER_TOUCH_INFO* contacts));
 };
 
 }  // namespace
 
 // A test to make sure that the touch event is converted correctly to
 // POINTER_TOUCH_INFO.
 TEST(TouchInjectorWinTest, CheckConversionWithPressure) {
-  scoped_ptr<TouchInjectorWinDelegateMock> delegate_mock(
+  std::unique_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(1234u);
   point->set_x(321.0f);
   point->set_y(123.0f);
   point->set_radius_x(10.0f);
   point->set_radius_y(20.0f);
@@ skipping 47 matching lines @@
   point->set_pressure(2.0f);
   injector.InjectTouchEvent(event);
 
   point->set_pressure(-3.0f);
   injector.InjectTouchEvent(event);
 }
 
 // Some devices don't detect pressure. This test is a conversion check for
 // such devices.
 TEST(TouchInjectorWinTest, CheckConversionNoPressure) {
-  scoped_ptr<TouchInjectorWinDelegateMock> delegate_mock(
+  std::unique_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(1234u);
   point->set_x(321.0f);
   point->set_y(123.0f);
   point->set_radius_x(10.0f);
   point->set_radius_y(20.0f);
@@ skipping 24 matching lines @@
       .WillOnce(Return(1));
 
   TouchInjectorWin injector;
   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(
+  std::unique_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(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>());
+  std::unique_ptr<TouchInjectorWinDelegateMock>
+      delegate_mock_before_deinitialize(
+          new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
+  std::unique_ptr<TouchInjectorWinDelegateMock>
+      delegate_mock_after_deinitialize(
+          new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
 
   TouchEvent first_event;
   first_event.set_event_type(TouchEvent::TOUCH_POINT_START);
   TouchEventPoint* point0 = first_event.add_touch_points();
   point0->set_id(0u);
 
   TouchEvent second_event;
   second_event.set_event_type(TouchEvent::TOUCH_POINT_START);
   TouchEventPoint* point1 = second_event.add_touch_points();
   point1->set_id(1u);
@@ skipping 30 matching lines @@
   injector.Deinitialize();
 
   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(
+  std::unique_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(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(
+  std::unique_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(_, _))
@@ skipping 15 matching lines @@
   TouchInjectorWin injector;
   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(
+  std::unique_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));
@@ skipping 14 matching lines @@
   TouchInjectorWin injector;
   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(
+  std::unique_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));
@@ skipping 21 matching lines @@
 
 // Note that points that haven't changed should be injected as MOVE.
 // This tests:
 // 1. Start first touch point.
 // 2. Start second touch point.
 // 3. Move both touch points.
 // 4. Start third touch point.
 // 5. End second touch point.
 // 6. Cancel remaining (first and third) touch points.
 TEST(TouchInjectorWinTest, MultiTouch) {
-  scoped_ptr<TouchInjectorWinDelegateMock> delegate_mock(
+  std::unique_ptr<TouchInjectorWinDelegateMock> delegate_mock(
       new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
 
   InSequence s;
   EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
       .WillOnce(Return(1));
 
   IdFlagMap id_to_flags;
   id_to_flags[0u] = kStartFlag;
   EXPECT_CALL(
       *delegate_mock,
@@ skipping 83 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