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

chrome/browser/chromeos/login/kiosk_browsertest.cc

 // Copyright (c) 2013 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 <vector>
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_controller_observer.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/app_mode/fake_cws.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_launch_error.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/file_manager/fake_disk_mount_manager.h"
@@ skipping 196 matching lines @@
   *out_locked = in_locked;
   runner_quit_task.Run();
 }
 
 // Helper function for WaitForNetworkTimeOut.
 void OnNetworkWaitTimedOut(const base::Closure& runner_quit_task) {
   runner_quit_task.Run();
 }
 
 // Helper function for LockFileThread.
-void LockAndUnlock(scoped_ptr<base::Lock> lock) {
+void LockAndUnlock(std::unique_ptr<base::Lock> lock) {
   lock->Acquire();
   lock->Release();
 }
 
 bool IsAppInstalled(const std::string& app_id, const std::string& version) {
   Profile* app_profile = ProfileManager::GetPrimaryUserProfile();
   DCHECK(app_profile);
   const extensions::Extension* app =
       extensions::ExtensionSystem::Get(app_profile)
           ->extension_service()
@@ skipping 471 matching lines @@
         &OnNetworkWaitTimedOut, runner->QuitClosure());
     AppLaunchController::SetNetworkTimeoutCallbackForTesting(&callback);
 
     runner->Run();
 
     CHECK(GetAppLaunchController()->network_wait_timedout());
     AppLaunchController::SetNetworkTimeoutCallbackForTesting(NULL);
   }
 
   void EnableConsumerKioskMode() {
-    scoped_ptr<bool> locked(new bool(false));
+    std::unique_ptr<bool> locked(new bool(false));
     scoped_refptr<content::MessageLoopRunner> runner =
         new content::MessageLoopRunner;
     KioskAppManager::Get()->EnableConsumerKioskAutoLaunch(
         base::Bind(&ConsumerKioskModeAutoStartLockCheck,
                    locked.get(),
                    runner->QuitClosure()));
     runner->Run();
     EXPECT_TRUE(*locked.get());
   }
 
@@ skipping 57 matching lines @@
     return LoginDisplayHost::default_host()->GetAppLaunchController();
   }
 
   // Returns a lock that is holding a task on the FILE thread. Any tasks posted
   // to the FILE thread after this call will be blocked until the returned
   // lock is released.
   // This can be used to prevent app installation from completing until some
   // other conditions are checked and triggered. For example, this can be used
   // to trigger the network screen during app launch without racing with the
   // app launching process itself.
-  scoped_ptr<base::AutoLock> LockFileThread() {
-    scoped_ptr<base::Lock> lock(new base::Lock);
-    scoped_ptr<base::AutoLock> auto_lock(new base::AutoLock(*lock));
+  std::unique_ptr<base::AutoLock> LockFileThread() {
+    std::unique_ptr<base::Lock> lock(new base::Lock);
+    std::unique_ptr<base::AutoLock> auto_lock(new base::AutoLock(*lock));
     content::BrowserThread::PostTask(
         content::BrowserThread::FILE, FROM_HERE,
         base::Bind(&LockAndUnlock, base::Passed(&lock)));
     return auto_lock;
   }
 
   MockUserManager* mock_user_manager() { return mock_user_manager_.get(); }
 
   void set_test_app_id(const std::string& test_app_id) {
     test_app_id_ = test_app_id;
   }
   const std::string& test_app_id() const { return test_app_id_; }
   void set_test_app_version(const std::string& version) {
     test_app_version_ = version;
   }
   const std::string& test_app_version() const { return test_app_version_; }
   void set_test_crx_file(const std::string& filename) {
     test_crx_file_ = filename;
   }
   const std::string& test_crx_file() const { return test_crx_file_; }
   FakeCWS* fake_cws() { return fake_cws_.get(); }
 
   void set_use_consumer_kiosk_mode(bool use) {
     use_consumer_kiosk_mode_ = use;
   }
 
   ScopedCrosSettingsTestHelper settings_helper_;
-  scoped_ptr<FakeOwnerSettingsService> owner_settings_service_;
+  std::unique_ptr<FakeOwnerSettingsService> owner_settings_service_;
 
   const AccountId test_owner_account_id_ =
       AccountId::FromUserEmail(kTestOwnerEmail);
 
  private:
   bool use_consumer_kiosk_mode_ = true;
   std::string test_app_id_;
   std::string test_app_version_;
   std::string test_crx_file_;
-  scoped_ptr<FakeCWS> fake_cws_;
-  scoped_ptr<MockUserManager> mock_user_manager_;
+  std::unique_ptr<FakeCWS> fake_cws_;
+  std::unique_ptr<MockUserManager> mock_user_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(KioskTest);
 };
 
 IN_PROC_BROWSER_TEST_F(KioskTest, InstallAndLaunchApp) {
   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
   WaitForAppLaunchSuccess();
   KioskAppManager::App app;
   ASSERT_TRUE(KioskAppManager::Get()->GetApp(test_app_id(), &app));
   EXPECT_FALSE(app.was_auto_launched_with_zero_delay);
@@ skipping 88 matching lines @@
 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppNetworkDown) {
   // Tests the network down case for launching an existing app that is
   // installed in PRE_LaunchAppNetworkDown.
   RunAppLaunchNetworkDownTest();
 }
 
 IN_PROC_BROWSER_TEST_F(KioskTest, LaunchAppWithNetworkConfigAccelerator) {
   ScopedCanConfigureNetwork can_configure_network(true, false);
 
   // Block app loading until the network screen is shown.
-  scoped_ptr<base::AutoLock> lock = LockFileThread();
+  std::unique_ptr<base::AutoLock> lock = LockFileThread();
 
   // Start app launch and wait for network connectivity timeout.
   StartAppLaunchFromLoginScreen(SimulateNetworkOnlineClosure());
   OobeScreenWaiter splash_waiter(OobeScreen::SCREEN_APP_LAUNCH_SPLASH);
   splash_waiter.Wait();
 
   // A network error screen should be shown after authenticating.
   OobeScreenWaiter error_screen_waiter(OobeScreen::SCREEN_ERROR_MESSAGE);
   // Simulate Ctrl+Alt+N accelerator.
   GetLoginUI()->CallJavascriptFunction(
@@ skipping 1348 matching lines @@
   content::WindowedNotificationObserver(
       chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
       content::NotificationService::AllSources()).Wait();
 
   // Wait for the wallpaper to load.
   WaitForWallpaper();
   EXPECT_TRUE(wallpaper_loaded());
 }
 
 }  // namespace chromeos