Convert //remoting to use std::unique_ptr

remoting/client/normalizing_input_filter_cros_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/client/normalizing_input_filter_cros.h"
 
 #include <stdint.h>
 
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/protocol_mock_objects.h"
@@ skipping 42 matching lines @@
   event.set_button(button);
   event.set_button_down(button_down);
   return event;
 }
 
 }  // namespace
 
 // Test OSKey press/release.
 TEST(NormalizingInputFilterCrosTest, PressReleaseOsKey) {
   MockInputStub stub;
-  scoped_ptr<protocol::InputFilter> processor(
+  std::unique_ptr<protocol::InputFilter> processor(
       new NormalizingInputFilterCros(&stub));
 
   {
     InSequence s;
 
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, false)));
 
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_RIGHT, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_RIGHT, false)));
   }
 
   // Inject press & release events for left & right OSKeys.
   PressAndReleaseKey(processor.get(), ui::DomCode::OS_LEFT);
   PressAndReleaseKey(processor.get(), ui::DomCode::OS_RIGHT);
 }
 
 // Test OSKey key repeat switches it to "modifying" mode.
 TEST(NormalizingInputFilterCrosTest, OSKeyRepeats) {
   MockInputStub stub;
-  scoped_ptr<protocol::InputFilter> processor(
+  std::unique_ptr<protocol::InputFilter> processor(
       new NormalizingInputFilterCros(&stub));
 
   {
     InSequence s;
 
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, true)));
     EXPECT_CALL(stub,InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, true)));
   }
 
   // Inject a press and repeats for the left OSKey, but don't release it, and
   // verify that the repeats result in press events.
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, true));
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, true));
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, true));
 }
 
 // Test OSKey press followed by function key press and release results in
 // just the function key events.
 TEST(NormalizingInputFilterCrosTest, FunctionKey) {
   MockInputStub stub;
-  scoped_ptr<protocol::InputFilter> processor(
+  std::unique_ptr<protocol::InputFilter> processor(
       new NormalizingInputFilterCros(&stub));
 
   {
     InSequence s;
 
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::F1, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::F1, false)));
   }
 
   // Hold the left OSKey while pressing & releasing the function key.
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, true));
   PressAndReleaseKey(processor.get(), ui::DomCode::F1);
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, false));
 }
 
 // Test OSKey press followed by extended key press and release results in
 // just the function key events.
 TEST(NormalizingInputFilterCrosTest, ExtendedKey) {
   MockInputStub stub;
-  scoped_ptr<protocol::InputFilter> processor(
+  std::unique_ptr<protocol::InputFilter> processor(
       new NormalizingInputFilterCros(&stub));
 
   {
     InSequence s;
 
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::INSERT, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::INSERT, false)));
   }
 
   // Hold the left OSKey while pressing & releasing the function key.
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, true));
   PressAndReleaseKey(processor.get(), ui::DomCode::INSERT);
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, false));
 }
 
 // Test OSKey press followed by non-function, non-extended key press and release
 // results in normal-looking sequence. We use the Tab key arbitrarily for this
 // test.
 TEST(NormalizingInputFilterCrosTest, OtherKey) {
   MockInputStub stub;
-  scoped_ptr<protocol::InputFilter> processor(
+  std::unique_ptr<protocol::InputFilter> processor(
       new NormalizingInputFilterCros(&stub));
 
   {
     InSequence s;
 
     EXPECT_CALL(stub,InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, true)));
     EXPECT_CALL(stub,InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::TAB, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::TAB, false)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, false)));
   }
 
   // Hold the left OSKey while pressing & releasing the function key.
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, true));
   PressAndReleaseKey(processor.get(), ui::DomCode::TAB);
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, false));
 }
 
 // Test OSKey press followed by extended key press, then normal key press
 // results in OSKey switching to modifying mode for the normal key.
 TEST(NormalizingInputFilterCrosTest, ExtendedThenOtherKey) {
   MockInputStub stub;
-  scoped_ptr<protocol::InputFilter> processor(
+  std::unique_ptr<protocol::InputFilter> processor(
       new NormalizingInputFilterCros(&stub));
 
   {
     InSequence s;
 
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::INSERT, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::INSERT, false)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::TAB, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::TAB, false)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, false)));
   }
 
   // Hold the left OSKey while pressing & releasing the function key.
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, true));
   PressAndReleaseKey(processor.get(), ui::DomCode::INSERT);
   PressAndReleaseKey(processor.get(), ui::DomCode::TAB);
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, false));
 }
 
 // Test OSKey press followed by mouse event puts the OSKey into modifying mode.
 TEST(NormalizingInputFilterCrosTest, MouseEvent) {
   MockInputStub stub;
-  scoped_ptr<protocol::InputFilter> processor(
+  std::unique_ptr<protocol::InputFilter> processor(
       new NormalizingInputFilterCros(&stub));
 
   {
     InSequence s;
 
     EXPECT_CALL(stub,InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, true)));
     EXPECT_CALL(stub, InjectMouseEvent(EqualsMouseMoveEvent(0, 0)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::OS_LEFT, false)));
   }
 
   // Hold the left OSKey while pressing & releasing the function key.
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, true));
   processor->InjectMouseEvent(MakeMouseMoveEvent(0, 0));
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::OS_LEFT, false));
 }
 
 // Test left alt + right click is remapped to left alt + left click.
 TEST(NormalizingInputFilterCrosTest, LeftAltClick) {
   MockInputStub stub;
-  scoped_ptr<protocol::InputFilter> processor(
+  std::unique_ptr<protocol::InputFilter> processor(
       new NormalizingInputFilterCros(&stub));
 
   {
     InSequence s;
 
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::ALT_LEFT, true)));
     EXPECT_CALL(stub, InjectMouseEvent(EqualsMouseButtonEvent(
                           MouseEvent::BUTTON_LEFT, true)));
     EXPECT_CALL(stub, InjectMouseEvent(EqualsMouseButtonEvent(
                           MouseEvent::BUTTON_LEFT, false)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::ALT_LEFT, false)));
   }
 
   // Hold the left alt key while left-clicking. ChromeOS will rewrite this as
   // Alt+RightClick
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::ALT_LEFT, true));
   processor->InjectMouseEvent(
       MakeMouseButtonEvent(MouseEvent::BUTTON_RIGHT, true));
   processor->InjectMouseEvent(
       MakeMouseButtonEvent(MouseEvent::BUTTON_RIGHT, false));
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::ALT_LEFT, false));
 }
 
 // Test that right alt + right click is unchanged.
 TEST(NormalizingInputFilterCrosTest, RightAltClick) {
   MockInputStub stub;
-  scoped_ptr<protocol::InputFilter> processor(
+  std::unique_ptr<protocol::InputFilter> processor(
       new NormalizingInputFilterCros(&stub));
 
   {
     InSequence s;
 
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::ALT_RIGHT, true)));
     EXPECT_CALL(stub, InjectMouseEvent(EqualsMouseButtonEvent(
                           MouseEvent::BUTTON_RIGHT, true)));
     EXPECT_CALL(stub, InjectMouseEvent(EqualsMouseButtonEvent(
                           MouseEvent::BUTTON_RIGHT, false)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEventWithNumLock(
         ui::DomCode::ALT_RIGHT, false)));
   }
 
   // Hold the right alt key while left-clicking. ChromeOS will rewrite this as
   // Alt+RightClick
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::ALT_RIGHT, true));
   processor->InjectMouseEvent(
       MakeMouseButtonEvent(MouseEvent::BUTTON_RIGHT, true));
   processor->InjectMouseEvent(
       MakeMouseButtonEvent(MouseEvent::BUTTON_RIGHT, false));
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::ALT_RIGHT, false));
 }
 
 // Test that the Alt-key remapping for Up and Down is not applied.
 TEST(NormalizingInputFilterCrosTest, UndoAltPlusArrowRemapping) {
   MockInputStub stub;
-  scoped_ptr<protocol::InputFilter> processor(
+  std::unique_ptr<protocol::InputFilter> processor(
       new NormalizingInputFilterCros(&stub));
 
   {
     InSequence s;
 
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEvent(
         ui::DomCode::ALT_LEFT, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEvent(
         ui::DomCode::ARROW_UP, true)));
     EXPECT_CALL(stub, InjectKeyEvent(EqualsKeyEvent(
@@ skipping 39 matching lines @@
 
   // Repeat the test for the right Alt key.
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::ALT_RIGHT, true));
   PressAndReleaseKey(processor.get(), ui::DomCode::PAGE_UP);
   PressAndReleaseKey(processor.get(), ui::DomCode::PAGE_DOWN);
   PressAndReleaseKey(processor.get(), ui::DomCode::DEL);
   processor->InjectKeyEvent(MakeKeyEvent(ui::DomCode::ALT_RIGHT, false));
 }
 
 }  // namespace remoting