Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/login/lock/screen_locker_browsertest.cc

 // Copyright 2014 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 "chrome/browser/chromeos/login/lock/screen_locker.h"
 
+#include <memory>
+
 #include "ash/wm/window_state.h"
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker_tester.h"
 #include "chrome/browser/chromeos/login/ui/user_adding_screen.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 41 matching lines @@
                const content::NotificationDetails& details) override {
     DCHECK(type == chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED ||
            type == chrome::NOTIFICATION_FULLSCREEN_CHANGED);
     if (running_)
       base::MessageLoop::current()->QuitWhenIdle();
   }
 
   // Wait until the two conditions are met.
   void Wait(bool locker_state, bool fullscreen) {
     running_ = true;
-    scoped_ptr<chromeos::test::ScreenLockerTester>
-        tester(chromeos::ScreenLocker::GetTester());
+    std::unique_ptr<chromeos::test::ScreenLockerTester> tester(
+        chromeos::ScreenLocker::GetTester());
     while (tester->IsLocked() != locker_state ||
            browser_->window()->IsFullscreen() != fullscreen) {
       content::RunMessageLoop();
     }
     // Make sure all pending tasks are executed.
     content::RunAllPendingInMessageLoop();
     running_ = false;
   }
 
  private:
@@ skipping 32 matching lines @@
   // Verifies if LockScreenDismissed() was called once.
   bool VerifyLockScreenDismissed() {
     return 1 == fake_session_manager_client_->
                     notify_lock_screen_dismissed_call_count();
   }
 
  private:
   void SetUpInProcessBrowserTestFixture() override {
     fake_session_manager_client_ = new FakeSessionManagerClient;
     DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
-        scoped_ptr<SessionManagerClient>(fake_session_manager_client_));
+        std::unique_ptr<SessionManagerClient>(fake_session_manager_client_));
 
     InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
     zero_duration_mode_.reset(new ui::ScopedAnimationDurationScaleMode(
         ui::ScopedAnimationDurationScaleMode::ZERO_DURATION));
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitchASCII(switches::kLoginProfile, "user");
   }
 
-  scoped_ptr<ui::ScopedAnimationDurationScaleMode> zero_duration_mode_;
+  std::unique_ptr<ui::ScopedAnimationDurationScaleMode> zero_duration_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLockerTest);
 };
 
 IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestBasic) {
   ScreenLocker::Show();
-  scoped_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
+  std::unique_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
   tester->EmulateWindowManagerReady();
   content::WindowedNotificationObserver lock_state_observer(
       chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
       content::NotificationService::AllSources());
   if (!tester->IsLocked())
     lock_state_observer.Wait();
 
   // Test to make sure that the widget is actually appearing and is of
   // reasonable size, preventing a regression of
   // http://code.google.com/p/chromium-os/issues/detail?id=5987
@@ skipping 27 matching lines @@
   content::RunAllPendingInMessageLoop();
   ScreenLocker::HandleLockScreenRequest();
 }
 
 // Test how locking the screen affects an active fullscreen window.
 IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestFullscreenExit) {
   // 1) If the active browser window is in fullscreen and the fullscreen window
   // does not have all the pixels (e.g. the shelf is auto hidden instead of
   // hidden), locking the screen should not exit fullscreen. The shelf is
   // auto hidden when in immersive fullscreen.
-  scoped_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
+  std::unique_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
   BrowserWindow* browser_window = browser()->window();
   ash::wm::WindowState* window_state = ash::wm::GetWindowState(
       browser_window->GetNativeWindow());
   {
     Waiter waiter(browser());
     browser()
         ->exclusive_access_manager()
         ->fullscreen_controller()
         ->ToggleBrowserFullscreenMode();
     waiter.Wait(false /* not locked */, true /* full screen */);
@@ skipping 66 matching lines @@
 void SimulateKeyPress(views::Widget* widget, ui::KeyboardCode key_code) {
   ui_controls::SendKeyPress(widget->GetNativeWindow(),
                             key_code, false, false, false, false);
 }
 
 void UnlockKeyPress(views::Widget* widget) {
   SimulateKeyPress(widget, ui::VKEY_SPACE);
 }
 
 IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestShowTwice) {
-  scoped_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
+  std::unique_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
   LockScreen(tester.get());
 
   // Calling Show again simply send LockCompleted signal.
   ScreenLocker::Show();
   EXPECT_TRUE(tester->IsLocked());
   EXPECT_EQ(
       2,
       fake_session_manager_client_->notify_lock_screen_shown_call_count());
 
 
   // Close the locker to match expectations.
   ScreenLocker::Hide();
   content::RunAllPendingInMessageLoop();
   EXPECT_FALSE(tester->IsLocked());
   EXPECT_TRUE(VerifyLockScreenDismissed());
 }
 
 // TODO(flackr): Find out why the RenderView isn't getting the escape press
 // and re-enable this test (currently this test is flaky).
 IN_PROC_BROWSER_TEST_F(ScreenLockerTest, DISABLED_TestEscape) {
-  scoped_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
+  std::unique_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
   LockScreen(tester.get());
 
   EXPECT_EQ(
       1,
       fake_session_manager_client_->notify_lock_screen_shown_call_count());
 
   tester->SetPassword("password");
   EXPECT_EQ("password", tester->GetPassword());
   // Escape clears the password.
   SimulateKeyPress(tester->GetWidget(), ui::VKEY_ESCAPE);
   content::RunAllPendingInMessageLoop();
   EXPECT_EQ("", tester->GetPassword());
 
   // Close the locker to match expectations.
   ScreenLocker::Hide();
   content::RunAllPendingInMessageLoop();
   EXPECT_FALSE(tester->IsLocked());
   EXPECT_TRUE(VerifyLockScreenDismissed());
 }
 
 }  // namespace chromeos