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

chrome/browser/chromeos/shutdown_policy_browsertest.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 <memory>
 #include <string>
 
 #include "ash/shell.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "ash/system/date/date_default_view.h"
 #include "ash/system/date/tray_date.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/tray_popup_header_button.h"
 #include "ash/system/user/login_status.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker_tester.h"
 #include "chrome/browser/chromeos/login/lock/webui_screen_locker.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/ui/webui_login_view.h"
 #include "chrome/browser/chromeos/policy/device_policy_builder.h"
@@ skipping 100 matching lines @@
   void WaitUntilOobeUIIsReady(OobeUI* oobe_ui) {
     ASSERT_TRUE(oobe_ui);
     base::RunLoop run_loop;
     const bool oobe_ui_ready = oobe_ui->IsJSReady(run_loop.QuitClosure());
     if (!oobe_ui_ready)
       run_loop.Run();
   }
 
   content::WebContents* contents_;
   bool result_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 };
 
 class ShutdownPolicyInSessionTest
     : public ShutdownPolicyBaseTest {
  protected:
   ShutdownPolicyInSessionTest() {}
   ~ShutdownPolicyInSessionTest() override {}
 
   void SetUpOnMainThread() override {
     ShutdownPolicyBaseTest::SetUpOnMainThread();
@@ skipping 19 matching lines @@
   }
 
   bool HasButtonTooltipText(const ash::TrayPopupHeaderButton* button,
                             int message_id) const {
     base::string16 actual_tooltip;
     button->GetTooltipText(gfx::Point(), &actual_tooltip);
     return l10n_util::GetStringUTF16(message_id) == actual_tooltip;
   }
 
  private:
-  scoped_ptr<ash::DateDefaultView> date_default_view_;
+  std::unique_ptr<ash::DateDefaultView> date_default_view_;
 
   DISALLOW_COPY_AND_ASSIGN(ShutdownPolicyInSessionTest);
 };
 
 IN_PROC_BROWSER_TEST_F(ShutdownPolicyInSessionTest, TestBasic) {
   const ash::TrayPopupHeaderButton *shutdown_button = GetShutdownButton();
   EXPECT_TRUE(
       HasButtonTooltipText(shutdown_button, IDS_ASH_STATUS_TRAY_SHUTDOWN));
 }
 
@@ skipping 12 matching lines @@
 }
 
 class ShutdownPolicyLockerTest : public ShutdownPolicyBaseTest {
  protected:
   ShutdownPolicyLockerTest() : fake_session_manager_client_(nullptr) {}
   ~ShutdownPolicyLockerTest() override {}
 
   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_));
 
     ShutdownPolicyBaseTest::SetUpInProcessBrowserTestFixture();
     zero_duration_mode_.reset(new ui::ScopedAnimationDurationScaleMode(
         ui::ScopedAnimationDurationScaleMode::ZERO_DURATION));
     InstallOwnerKey();
     MarkAsEnterpriseOwned();
   }
 
   void SetUpOnMainThread() override {
     ShutdownPolicyBaseTest::SetUpOnMainThread();
 
     // Bring up the locker screen.
     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();
     ScreenLocker* screen_locker = ScreenLocker::default_screen_locker();
     WebUIScreenLocker* web_ui_screen_locker =
         static_cast<WebUIScreenLocker*>(screen_locker->delegate());
     ASSERT_TRUE(web_ui_screen_locker);
     content::WebUI* web_ui = web_ui_screen_locker->GetWebUI();
     ASSERT_TRUE(web_ui);
     contents_ = web_ui->GetWebContents();
     ASSERT_TRUE(contents_);
 
     // Wait for the login UI to be ready.
     WaitUntilOobeUIIsReady(
         static_cast<OobeUI*>(web_ui->GetController()));
   }
 
  private:
-  scoped_ptr<ui::ScopedAnimationDurationScaleMode> zero_duration_mode_;
+  std::unique_ptr<ui::ScopedAnimationDurationScaleMode> zero_duration_mode_;
   FakeSessionManagerClient* fake_session_manager_client_;
 
   DISALLOW_COPY_AND_ASSIGN(ShutdownPolicyLockerTest);
 };
 
 IN_PROC_BROWSER_TEST_F(ShutdownPolicyLockerTest, TestBasic) {
   PrepareAndRunScript("restart-header-bar-item", true);
   PrepareAndRunScript("shutdown-header-bar-item", false);
 }
 
@@ skipping 69 matching lines @@
   PrepareAndRunScript("restart-header-bar-item", false);
   PrepareAndRunScript("shutdown-header-bar-item", true);
 
   UpdateRebootOnShutdownPolicy(false);
   RefreshDevicePolicy();
   PrepareAndRunScript("restart-header-bar-item", true);
   PrepareAndRunScript("shutdown-header-bar-item", false);
 }
 
 }  // namespace chromeos