Convert //ash from scoped_ptr to std::unique_ptr

ash/accelerators/accelerator_controller_unittest.cc

 // Copyright (c) 2012 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 "ash/accelerators/accelerator_controller.h"
 
 #include "ash/accelerators/accelerator_table.h"
 #include "ash/accessibility_delegate.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
@@ skipping 422 matching lines @@
   const ui::Accelerator accelerator_shift_a(ui::VKEY_A, ui::EF_SHIFT_DOWN);
   TestTarget target;
   GetController()->Register(accelerator_a, &target);
   EXPECT_TRUE(GetController()->IsRegistered(accelerator_a));
   EXPECT_FALSE(GetController()->IsRegistered(accelerator_shift_a));
   GetController()->UnregisterAll(&target);
   EXPECT_FALSE(GetController()->IsRegistered(accelerator_a));
 }
 
 TEST_F(AcceleratorControllerTest, WindowSnap) {
-  scoped_ptr<aura::Window> window(
+  std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
   wm::WindowState* window_state = wm::GetWindowState(window.get());
 
   window_state->Activate();
 
   {
     GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
     gfx::Rect expected_bounds = wm::GetDefaultLeftSnappedWindowBoundsInParent(
         window.get());
     EXPECT_EQ(expected_bounds.ToString(), window->bounds().ToString());
@@ skipping 33 matching lines @@
     window_state->Restore();
     window_state->Activate();
   }
   {
     GetController()->PerformActionIfEnabled(WINDOW_MINIMIZE);
     EXPECT_TRUE(window_state->IsMinimized());
   }
 }
 
 TEST_F(AcceleratorControllerTest, WindowSnapLeftDockLeftRestore) {
-  scoped_ptr<aura::Window> window0(
+  std::unique_ptr<aura::Window> window0(
       CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
-  scoped_ptr<aura::Window> window1(
-    CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
+  std::unique_ptr<aura::Window> window1(
+      CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
   wm::WindowState* window1_state = wm::GetWindowState(window1.get());
   window1_state->Activate();
 
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   gfx::Rect normal_bounds = window1_state->GetRestoreBoundsInParent();
   gfx::Rect expected_bounds = wm::GetDefaultLeftSnappedWindowBoundsInParent(
                                 window1.get());
   EXPECT_EQ(expected_bounds.ToString(), window1->bounds().ToString());
   EXPECT_TRUE(window1_state->IsSnapped());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   EXPECT_FALSE(window1_state->IsNormalOrSnapped());
   EXPECT_TRUE(window1_state->IsDocked());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   EXPECT_FALSE(window1_state->IsDocked());
   EXPECT_EQ(normal_bounds.ToString(), window1->bounds().ToString());
 }
 
 TEST_F(AcceleratorControllerTest, WindowSnapRightDockRightRestore) {
-  scoped_ptr<aura::Window> window0(
+  std::unique_ptr<aura::Window> window0(
       CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
-  scoped_ptr<aura::Window> window1(
-    CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
+  std::unique_ptr<aura::Window> window1(
+      CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
 
   wm::WindowState* window1_state = wm::GetWindowState(window1.get());
   window1_state->Activate();
 
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   gfx::Rect normal_bounds = window1_state->GetRestoreBoundsInParent();
   gfx::Rect expected_bounds =
     wm::GetDefaultRightSnappedWindowBoundsInParent(window1.get());
   EXPECT_EQ(expected_bounds.ToString(), window1->bounds().ToString());
   EXPECT_TRUE(window1_state->IsSnapped());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   EXPECT_FALSE(window1_state->IsNormalOrSnapped());
   EXPECT_TRUE(window1_state->IsDocked());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   EXPECT_FALSE(window1_state->IsDocked());
   EXPECT_EQ(normal_bounds.ToString(), window1->bounds().ToString());
 }
 
 TEST_F(AcceleratorControllerTest, WindowSnapLeftDockLeftSnapRight) {
-  scoped_ptr<aura::Window> window0(
+  std::unique_ptr<aura::Window> window0(
       CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
-  scoped_ptr<aura::Window> window1(
-    CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
+  std::unique_ptr<aura::Window> window1(
+      CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
 
   wm::WindowState* window1_state = wm::GetWindowState(window1.get());
   window1_state->Activate();
 
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   gfx::Rect expected_bounds =
     wm::GetDefaultLeftSnappedWindowBoundsInParent(window1.get());
   gfx::Rect expected_bounds2 =
     wm::GetDefaultRightSnappedWindowBoundsInParent(window1.get());
   EXPECT_EQ(expected_bounds.ToString(), window1->bounds().ToString());
   EXPECT_TRUE(window1_state->IsSnapped());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   EXPECT_FALSE(window1_state->IsNormalOrSnapped());
   EXPECT_TRUE(window1_state->IsDocked());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   EXPECT_FALSE(window1_state->IsDocked());
   EXPECT_TRUE(window1_state->IsSnapped());
   EXPECT_EQ(expected_bounds2.ToString(), window1->bounds().ToString());
 }
 
 TEST_F(AcceleratorControllerTest, WindowDockLeftMinimizeWindowWithRestore) {
-  scoped_ptr<aura::Window> window0(
+  std::unique_ptr<aura::Window> window0(
       CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
-  scoped_ptr<aura::Window> window1(
-    CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
+  std::unique_ptr<aura::Window> window1(
+      CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
 
   wm::WindowState* window1_state = wm::GetWindowState(window1.get());
   window1_state->Activate();
 
-  scoped_ptr<aura::Window> window2(
-    CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
+  std::unique_ptr<aura::Window> window2(
+      CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
 
   wm::WindowState* window2_state = wm::GetWindowState(window2.get());
 
-  scoped_ptr<aura::Window> window3(
-    CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
+  std::unique_ptr<aura::Window> window3(
+      CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
 
   wm::WindowState* window3_state = wm::GetWindowState(window3.get());
   window3_state->Activate();
 
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   gfx::Rect window3_docked_bounds = window3->bounds();
 
   window2_state->Activate();
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
@@ skipping 12 matching lines @@
   window2_state->Activate();
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   window3_state->Unminimize();
   EXPECT_FALSE(window1_state->IsDocked());
   EXPECT_FALSE(window2_state->IsDocked());
   EXPECT_TRUE(window3_state->IsDocked());
   EXPECT_EQ(window3_docked_bounds.ToString(), window3->bounds().ToString());
 }
 
 TEST_F(AcceleratorControllerTest, WindowPanelDockLeftDockRightRestore) {
-  scoped_ptr<aura::Window> window0(
+  std::unique_ptr<aura::Window> window0(
       CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
 
-  scoped_ptr<aura::Window> window(CreatePanel());
+  std::unique_ptr<aura::Window> window(CreatePanel());
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->Activate();
 
   gfx::Rect window_restore_bounds2 = window->bounds();
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   gfx::Rect expected_bounds =
       wm::GetDefaultLeftSnappedWindowBoundsInParent(window.get());
   gfx::Rect window_restore_bounds =
       window_state->GetRestoreBoundsInScreen();
   EXPECT_NE(expected_bounds.ToString(), window->bounds().ToString());
   EXPECT_FALSE(window_state->IsSnapped());
   EXPECT_FALSE(window_state->IsNormalOrSnapped());
   EXPECT_TRUE(window_state->IsDocked());
   window_state->Restore();
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   EXPECT_TRUE(window_state->IsDocked());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   EXPECT_FALSE(window_state->IsDocked());
   EXPECT_EQ(window_restore_bounds.ToString(),
             window_restore_bounds2.ToString());
   EXPECT_EQ(window_restore_bounds.ToString(), window->bounds().ToString());
 }
 
 TEST_F(AcceleratorControllerTest, CenterWindowAccelerator) {
-  scoped_ptr<aura::Window> window(
+  std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->Activate();
 
   // Center the window using accelerator.
   GetController()->PerformActionIfEnabled(WINDOW_POSITION_CENTER);
   gfx::Rect work_area = gfx::Screen::GetScreen()
                             ->GetDisplayNearestWindow(window.get())
                             .work_area();
   gfx::Rect bounds = window->GetBoundsInScreen();
@@ skipping 205 matching lines @@
     EXPECT_TRUE(ProcessInController(ui::Accelerator(
         ui::VKEY_MEDIA_LAUNCH_APP1, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN)));
     EXPECT_EQ(2, delegate->handle_take_screenshot_count());
   }
   const ui::Accelerator volume_mute(ui::VKEY_VOLUME_MUTE, ui::EF_NONE);
   const ui::Accelerator volume_down(ui::VKEY_VOLUME_DOWN, ui::EF_NONE);
   const ui::Accelerator volume_up(ui::VKEY_VOLUME_UP, ui::EF_NONE);
   {
     TestVolumeControlDelegate* delegate = new TestVolumeControlDelegate;
     ash::Shell::GetInstance()->system_tray_delegate()->SetVolumeControlDelegate(
-        scoped_ptr<VolumeControlDelegate>(delegate));
+        std::unique_ptr<VolumeControlDelegate>(delegate));
     EXPECT_EQ(0, delegate->handle_volume_mute_count());
     EXPECT_TRUE(ProcessInController(volume_mute));
     EXPECT_EQ(1, delegate->handle_volume_mute_count());
     EXPECT_EQ(volume_mute, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_volume_down_count());
     EXPECT_TRUE(ProcessInController(volume_down));
     EXPECT_EQ(1, delegate->handle_volume_down_count());
     EXPECT_EQ(volume_down, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_volume_up_count());
     EXPECT_TRUE(ProcessInController(volume_up));
     EXPECT_EQ(1, delegate->handle_volume_up_count());
     EXPECT_EQ(volume_up, delegate->last_accelerator());
   }
   // Brightness
   // ui::VKEY_BRIGHTNESS_DOWN/UP are not defined on Windows.
   const ui::Accelerator brightness_down(ui::VKEY_BRIGHTNESS_DOWN, ui::EF_NONE);
   const ui::Accelerator brightness_up(ui::VKEY_BRIGHTNESS_UP, ui::EF_NONE);
   {
     DummyBrightnessControlDelegate* delegate =
         new DummyBrightnessControlDelegate;
     GetController()->SetBrightnessControlDelegate(
-        scoped_ptr<BrightnessControlDelegate>(delegate));
+        std::unique_ptr<BrightnessControlDelegate>(delegate));
     EXPECT_EQ(0, delegate->handle_brightness_down_count());
     EXPECT_TRUE(ProcessInController(brightness_down));
     EXPECT_EQ(1, delegate->handle_brightness_down_count());
     EXPECT_EQ(brightness_down, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_brightness_up_count());
     EXPECT_TRUE(ProcessInController(brightness_up));
     EXPECT_EQ(1, delegate->handle_brightness_up_count());
     EXPECT_EQ(brightness_up, delegate->last_accelerator());
   }
 
   // Keyboard brightness
   const ui::Accelerator alt_brightness_down(ui::VKEY_BRIGHTNESS_DOWN,
                                             ui::EF_ALT_DOWN);
   const ui::Accelerator alt_brightness_up(ui::VKEY_BRIGHTNESS_UP,
                                           ui::EF_ALT_DOWN);
   {
     EXPECT_TRUE(ProcessInController(alt_brightness_down));
     EXPECT_TRUE(ProcessInController(alt_brightness_up));
     DummyKeyboardBrightnessControlDelegate* delegate =
         new DummyKeyboardBrightnessControlDelegate;
     GetController()->SetKeyboardBrightnessControlDelegate(
-        scoped_ptr<KeyboardBrightnessControlDelegate>(delegate));
+        std::unique_ptr<KeyboardBrightnessControlDelegate>(delegate));
     EXPECT_EQ(0, delegate->handle_keyboard_brightness_down_count());
     EXPECT_TRUE(ProcessInController(alt_brightness_down));
     EXPECT_EQ(1, delegate->handle_keyboard_brightness_down_count());
     EXPECT_EQ(alt_brightness_down, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_keyboard_brightness_up_count());
     EXPECT_TRUE(ProcessInController(alt_brightness_up));
     EXPECT_EQ(1, delegate->handle_keyboard_brightness_up_count());
     EXPECT_EQ(alt_brightness_up, delegate->last_accelerator());
   }
 #endif
@@ skipping 121 matching lines @@
     const ui::Accelerator hangul(ui::VKEY_HANGUL, ui::EF_NONE);
     EXPECT_FALSE(ProcessInController(control_space_down));
     EXPECT_FALSE(ProcessInController(control_space_up));
     EXPECT_FALSE(ProcessInController(convert));
     EXPECT_FALSE(ProcessInController(non_convert));
     EXPECT_FALSE(ProcessInController(wide_half_1));
     EXPECT_FALSE(ProcessInController(wide_half_2));
     EXPECT_FALSE(ProcessInController(hangul));
     DummyImeControlDelegate* delegate = new DummyImeControlDelegate;
     GetController()->SetImeControlDelegate(
-        scoped_ptr<ImeControlDelegate>(delegate));
+        std::unique_ptr<ImeControlDelegate>(delegate));
     EXPECT_EQ(0, delegate->handle_previous_ime_count());
     EXPECT_TRUE(ProcessInController(control_space_down));
     EXPECT_EQ(1, delegate->handle_previous_ime_count());
     EXPECT_TRUE(ProcessInController(control_space_up));
     EXPECT_EQ(1, delegate->handle_previous_ime_count());
     EXPECT_EQ(0, delegate->handle_switch_ime_count());
     EXPECT_TRUE(ProcessInController(convert));
     EXPECT_EQ(1, delegate->handle_switch_ime_count());
     EXPECT_TRUE(ProcessInController(non_convert));
     EXPECT_EQ(2, delegate->handle_switch_ime_count());
     EXPECT_TRUE(ProcessInController(wide_half_1));
     EXPECT_EQ(3, delegate->handle_switch_ime_count());
     EXPECT_TRUE(ProcessInController(wide_half_2));
     EXPECT_EQ(4, delegate->handle_switch_ime_count());
     EXPECT_TRUE(ProcessInController(hangul));
     EXPECT_EQ(5, delegate->handle_switch_ime_count());
   }
 
   // Test IME shortcuts that are triggered on key release.
   {
     const ui::Accelerator shift_alt_press(ui::VKEY_MENU,
                                           ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
     const ReleaseAccelerator shift_alt(ui::VKEY_MENU, ui::EF_SHIFT_DOWN);
     const ui::Accelerator alt_shift_press(ui::VKEY_SHIFT,
                                           ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
     const ReleaseAccelerator alt_shift(ui::VKEY_SHIFT, ui::EF_ALT_DOWN);
 
     DummyImeControlDelegate* delegate = new DummyImeControlDelegate;
     GetController()->SetImeControlDelegate(
-        scoped_ptr<ImeControlDelegate>(delegate));
+        std::unique_ptr<ImeControlDelegate>(delegate));
     EXPECT_EQ(0, delegate->handle_next_ime_count());
     EXPECT_FALSE(ProcessInController(shift_alt_press));
     EXPECT_TRUE(ProcessInController(shift_alt));
     EXPECT_EQ(1, delegate->handle_next_ime_count());
     EXPECT_FALSE(ProcessInController(alt_shift_press));
     EXPECT_TRUE(ProcessInController(alt_shift));
     EXPECT_EQ(2, delegate->handle_next_ime_count());
 
     // We should NOT switch IME when e.g. Shift+Alt+X is pressed and X is
     // released.
@@ skipping 41 matching lines @@
 #if defined(OS_CHROMEOS)
   // Test IME shortcuts again with unnormalized accelerators (Chrome OS only).
   {
     const ui::Accelerator shift_alt_press(ui::VKEY_MENU, ui::EF_SHIFT_DOWN);
     const ReleaseAccelerator shift_alt(ui::VKEY_MENU, ui::EF_SHIFT_DOWN);
     const ui::Accelerator alt_shift_press(ui::VKEY_SHIFT, ui::EF_ALT_DOWN);
     const ReleaseAccelerator alt_shift(ui::VKEY_SHIFT, ui::EF_ALT_DOWN);
 
     DummyImeControlDelegate* delegate = new DummyImeControlDelegate;
     GetController()->SetImeControlDelegate(
-        scoped_ptr<ImeControlDelegate>(delegate));
+        std::unique_ptr<ImeControlDelegate>(delegate));
     EXPECT_EQ(0, delegate->handle_next_ime_count());
     EXPECT_FALSE(ProcessInController(shift_alt_press));
     EXPECT_TRUE(ProcessInController(shift_alt));
     EXPECT_EQ(1, delegate->handle_next_ime_count());
     EXPECT_FALSE(ProcessInController(alt_shift_press));
     EXPECT_TRUE(ProcessInController(alt_shift));
     EXPECT_EQ(2, delegate->handle_next_ime_count());
 
     // We should NOT switch IME when e.g. Shift+Alt+X is pressed and X is
     // released.
@@ skipping 25 matching lines @@
       ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
   EXPECT_FALSE(ProcessInController(shift_alt_space_press));
 }
 
 // Makes sure that the next IME accelerators doesn't conflict with other
 // accelerators that contain Alt+Shift when the wrong sequence is pressed.
 // crbug.com/527154.
 TEST_F(AcceleratorControllerTest, ImeGlobalAcceleratorsNoConflict) {
   DummyImeControlDelegate* delegate = new DummyImeControlDelegate;
   GetController()->SetImeControlDelegate(
-      scoped_ptr<ImeControlDelegate>(delegate));
+      std::unique_ptr<ImeControlDelegate>(delegate));
   ui::test::EventGenerator& generator = GetEventGenerator();
 
   // Correct sequence of a conflicting accelerator must not trigger next IME.
   // Alt (press) + Shift (press) + S (press) + S (release) + Shift (release) +
   // Alt (release).
   generator.PressKey(ui::VKEY_MENU, ui::EF_ALT_DOWN);
   generator.PressKey(ui::VKEY_SHIFT, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
   generator.PressKey(ui::VKEY_S, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
   generator.ReleaseKey(ui::VKEY_S, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
   generator.ReleaseKey(ui::VKEY_SHIFT, ui::EF_ALT_DOWN);
@@ skipping 149 matching lines @@
     actionsAllowedAtModalWindow.insert(kActionsAllowedAtModalWindow[k]);
   for (std::set<AcceleratorAction>::const_iterator it =
            actionsAllowedAtModalWindow.begin();
        it != actionsAllowedAtModalWindow.end(); ++it) {
     EXPECT_TRUE(all_actions.find(*it) != all_actions.end() ||
                 all_debug_actions.find(*it) != all_debug_actions.end())
         << " action from kActionsAllowedAtModalWindow"
         << " not found in kAcceleratorData or kDebugAcceleratorData. "
         << "action: " << *it;
   }
-  scoped_ptr<aura::Window> window(
+  std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
   wm::ActivateWindow(window.get());
   Shell::GetInstance()->SimulateModalWindowOpenForTesting(true);
   for (std::set<AcceleratorAction>::const_iterator it = all_actions.begin();
        it != all_actions.end(); ++it) {
     if (actionsAllowedAtModalWindow.find(*it) ==
         actionsAllowedAtModalWindow.end()) {
       EXPECT_TRUE(GetController()->PerformActionIfEnabled(*it))
           << " for action (disallowed at modal window): " << *it;
     }
@@ skipping 25 matching lines @@
         ui::VKEY_MEDIA_LAUNCH_APP1, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN)));
     EXPECT_EQ(2, delegate->handle_take_screenshot_count());
   }
   // Brightness
   const ui::Accelerator brightness_down(ui::VKEY_BRIGHTNESS_DOWN, ui::EF_NONE);
   const ui::Accelerator brightness_up(ui::VKEY_BRIGHTNESS_UP, ui::EF_NONE);
   {
     DummyBrightnessControlDelegate* delegate =
         new DummyBrightnessControlDelegate;
     GetController()->SetBrightnessControlDelegate(
-        scoped_ptr<BrightnessControlDelegate>(delegate));
+        std::unique_ptr<BrightnessControlDelegate>(delegate));
     EXPECT_EQ(0, delegate->handle_brightness_down_count());
     EXPECT_TRUE(ProcessInController(brightness_down));
     EXPECT_EQ(1, delegate->handle_brightness_down_count());
     EXPECT_EQ(brightness_down, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_brightness_up_count());
     EXPECT_TRUE(ProcessInController(brightness_up));
     EXPECT_EQ(1, delegate->handle_brightness_up_count());
     EXPECT_EQ(brightness_up, delegate->last_accelerator());
   }
   // Volume
   const ui::Accelerator volume_mute(ui::VKEY_VOLUME_MUTE, ui::EF_NONE);
   const ui::Accelerator volume_down(ui::VKEY_VOLUME_DOWN, ui::EF_NONE);
   const ui::Accelerator volume_up(ui::VKEY_VOLUME_UP, ui::EF_NONE);
   {
     EXPECT_TRUE(ProcessInController(volume_mute));
     EXPECT_TRUE(ProcessInController(volume_down));
     EXPECT_TRUE(ProcessInController(volume_up));
     TestVolumeControlDelegate* delegate = new TestVolumeControlDelegate;
     ash::Shell::GetInstance()->system_tray_delegate()->SetVolumeControlDelegate(
-        scoped_ptr<VolumeControlDelegate>(delegate));
+        std::unique_ptr<VolumeControlDelegate>(delegate));
     EXPECT_EQ(0, delegate->handle_volume_mute_count());
     EXPECT_TRUE(ProcessInController(volume_mute));
     EXPECT_EQ(1, delegate->handle_volume_mute_count());
     EXPECT_EQ(volume_mute, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_volume_down_count());
     EXPECT_TRUE(ProcessInController(volume_down));
     EXPECT_EQ(1, delegate->handle_volume_down_count());
     EXPECT_EQ(volume_down, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_volume_up_count());
     EXPECT_TRUE(ProcessInController(volume_up));
     EXPECT_EQ(1, delegate->handle_volume_up_count());
     EXPECT_EQ(volume_up, delegate->last_accelerator());
   }
 }
 #endif
 
 TEST_F(AcceleratorControllerTest, DisallowedWithNoWindow) {
   AccessibilityDelegate* delegate =
       ash::Shell::GetInstance()->accessibility_delegate();
 
   for (size_t i = 0; i < kActionsNeedingWindowLength; ++i) {
     delegate->TriggerAccessibilityAlert(ui::A11Y_ALERT_NONE);
     EXPECT_TRUE(
         GetController()->PerformActionIfEnabled(kActionsNeedingWindow[i]));
     EXPECT_EQ(delegate->GetLastAccessibilityAlert(),
               ui::A11Y_ALERT_WINDOW_NEEDED);
   }
 
   // Make sure we don't alert if we do have a window.
-  scoped_ptr<aura::Window> window;
+  std::unique_ptr<aura::Window> window;
   for (size_t i = 0; i < kActionsNeedingWindowLength; ++i) {
     window.reset(CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
     wm::ActivateWindow(window.get());
     delegate->TriggerAccessibilityAlert(ui::A11Y_ALERT_NONE);
     GetController()->PerformActionIfEnabled(kActionsNeedingWindow[i]);
     EXPECT_NE(delegate->GetLastAccessibilityAlert(),
               ui::A11Y_ALERT_WINDOW_NEEDED);
   }
 
   // Don't alert if we have a minimized window either.
@@ skipping 16 matching lines @@
  public:
   DeprecatedAcceleratorTester() {}
   ~DeprecatedAcceleratorTester() override {}
 
   void SetUp() override {
     AcceleratorControllerTest::SetUp();
 
     // For testing the deprecated and new IME shortcuts.
     DummyImeControlDelegate* delegate = new DummyImeControlDelegate;
     GetController()->SetImeControlDelegate(
-        scoped_ptr<ImeControlDelegate>(delegate));
+        std::unique_ptr<ImeControlDelegate>(delegate));
   }
 
   ui::Accelerator CreateAccelerator(const AcceleratorData& data) const {
     ui::Accelerator result(data.keycode, data.modifiers);
     result.set_type(data.trigger_on_press ? ui::ET_KEY_PRESSED
                                           : ui::ET_KEY_RELEASED);
     return result;
   }
 
   void ResetStateIfNeeded() {
@@ skipping 70 matching lines @@
     EXPECT_TRUE(IsMessageCenterEmpty());
 
     // If the action is LOCK_SCREEN, we must reset the state by unlocking the
     // screen before we proceed testing the rest of accelerators.
     ResetStateIfNeeded();
   }
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace ash