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

chrome/browser/chromeos/login/wizard_controller_browsertest.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 "chrome/browser/chromeos/login/wizard_controller.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 165 matching lines @@
     base::RunLoop* loop,
     policy::AutoEnrollmentState actual_state) {
   if (expected_state == actual_state)
     loop->Quit();
 }
 
 void WaitForAutoEnrollmentState(policy::AutoEnrollmentState state) {
   base::RunLoop loop;
   AutoEnrollmentController* auto_enrollment_controller =
       LoginDisplayHost::default_host()->GetAutoEnrollmentController();
-  scoped_ptr<AutoEnrollmentController::ProgressCallbackList::Subscription>
+  std::unique_ptr<AutoEnrollmentController::ProgressCallbackList::Subscription>
       progress_subscription(
           auto_enrollment_controller->RegisterProgressCallback(
               base::Bind(&QuitLoopOnAutoEnrollmentProgress, state, &loop)));
   loop.Run();
 }
 
 }  // namespace
 
 using ::testing::_;
 
@@ skipping 14 matching lines @@
 
   void RealShow() {
     T::Show();
   }
 
   void RealHide() {
     T::Hide();
   }
 
  private:
-  scoped_ptr<H> actor_;
+  std::unique_ptr<H> actor_;
 };
 
 #define MOCK(mock_var, screen_name, mocked_class, actor_class)               \
   mock_var = new MockOutShowHide<mocked_class, actor_class>(                 \
       WizardController::default_controller(), new actor_class);              \
   WizardController::default_controller()                                     \
       ->screens_[WizardController::screen_name] = make_linked_ptr(mock_var); \
   EXPECT_CALL(*mock_var, Show()).Times(0);                                   \
   EXPECT_CALL(*mock_var, Hide()).Times(0);
 
@@ skipping 129 matching lines @@
   // Check that output is unmuted now and at some level.
   CrasAudioHandler* cras = CrasAudioHandler::Get();
   ASSERT_FALSE(cras->IsOutputMuted());
   ASSERT_EQ(WizardController::kMinAudibleOutputVolumePercent,
             cras->GetOutputVolumePercent());
 }
 
 class WizardControllerTestURLFetcherFactory
     : public net::TestURLFetcherFactory {
  public:
-  scoped_ptr<net::URLFetcher> CreateURLFetcher(
+  std::unique_ptr<net::URLFetcher> CreateURLFetcher(
       int id,
       const GURL& url,
       net::URLFetcher::RequestType request_type,
       net::URLFetcherDelegate* d) override {
     if (base::StartsWith(
             url.spec(),
             SimpleGeolocationProvider::DefaultGeolocationProviderURL().spec(),
             base::CompareCase::SENSITIVE)) {
-      return scoped_ptr<net::URLFetcher>(new net::FakeURLFetcher(
+      return std::unique_ptr<net::URLFetcher>(new net::FakeURLFetcher(
           url, d, std::string(kGeolocationResponseBody), net::HTTP_OK,
           net::URLRequestStatus::SUCCESS));
     }
     if (base::StartsWith(url.spec(),
                          chromeos::DefaultTimezoneProviderURL().spec(),
                          base::CompareCase::SENSITIVE)) {
-      return scoped_ptr<net::URLFetcher>(new net::FakeURLFetcher(
+      return std::unique_ptr<net::URLFetcher>(new net::FakeURLFetcher(
           url, d, std::string(kTimezoneResponseBody), net::HTTP_OK,
           net::URLRequestStatus::SUCCESS));
     }
     return net::TestURLFetcherFactory::CreateURLFetcher(
         id, url, request_type, d);
   }
   ~WizardControllerTestURLFetcherFactory() override {}
 };
 
 class TimeZoneTestRunner {
@@ skipping 102 matching lines @@
   void OnExit(BaseScreen& screen, BaseScreenDelegate::ExitCodes exit_code) {
     WizardController::default_controller()->OnExit(screen, exit_code,
                                                    nullptr /* context */);
   }
 
   chromeos::SimpleGeolocationProvider* GetGeolocationProvider() {
     return WizardController::default_controller()->geolocation_provider_.get();
   }
 
   void WaitUntilTimezoneResolved() {
-    scoped_ptr<TimeZoneTestRunner> runner(new TimeZoneTestRunner);
+    std::unique_ptr<TimeZoneTestRunner> runner(new TimeZoneTestRunner);
     if (!WizardController::default_controller()
              ->SetOnTimeZoneResolvedForTesting(
                  base::Bind(&TimeZoneTestRunner::OnResolved,
                             base::Unretained(runner.get()))))
       return;
 
     runner->Run();
   }
 
   void ResetAutoEnrollmentCheckScreen() {
     WizardController::default_controller()->screens_.erase(
         WizardController::kAutoEnrollmentCheckScreenName);
   }
 
   linked_ptr<MockNetworkScreen> mock_network_screen_;
   MockOutShowHide<MockUpdateScreen, MockUpdateView>* mock_update_screen_;
   MockOutShowHide<MockEulaScreen, MockEulaView>* mock_eula_screen_;
   MockOutShowHide<MockEnrollmentScreen,
       MockEnrollmentScreenActor>* mock_enrollment_screen_;
   MockOutShowHide<MockAutoEnrollmentCheckScreen,
       MockAutoEnrollmentCheckScreenActor>* mock_auto_enrollment_check_screen_;
   MockOutShowHide<MockWrongHWIDScreen, MockWrongHWIDScreenActor>*
       mock_wrong_hwid_screen_;
   MockOutShowHide<MockEnableDebuggingScreen,
       MockEnableDebuggingScreenActor>* mock_enable_debugging_screen_;
-  scoped_ptr<MockDeviceDisabledScreenActor> device_disabled_screen_actor_;
+  std::unique_ptr<MockDeviceDisabledScreenActor> device_disabled_screen_actor_;
 
  private:
   NetworkPortalDetectorTestImpl* network_portal_detector_;
 
   // Use a test factory as a fallback so we don't have to deal with other
   // requests.
-  scoped_ptr<WizardControllerTestURLFetcherFactory> fallback_fetcher_factory_;
-  scoped_ptr<net::FakeURLFetcherFactory> fetcher_factory_;
+  std::unique_ptr<WizardControllerTestURLFetcherFactory>
+      fallback_fetcher_factory_;
+  std::unique_ptr<net::FakeURLFetcherFactory> fetcher_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WizardControllerFlowTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowMain) {
   CheckCurrentScreen(WizardController::kNetworkScreenName);
 
   WaitUntilJSIsReady();
 
   // Check visibility of the header bar.
@@ skipping 341 matching lines @@
       : fake_session_manager_client_(NULL) {
   }
 
   ~WizardControllerBrokenLocalStateTest() override {}
 
   void SetUpInProcessBrowserTestFixture() override {
     WizardControllerTest::SetUpInProcessBrowserTestFixture();
 
     fake_session_manager_client_ = new FakeSessionManagerClient;
     DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
-        scoped_ptr<SessionManagerClient>(fake_session_manager_client_));
+        std::unique_ptr<SessionManagerClient>(fake_session_manager_client_));
   }
 
   void SetUpOnMainThread() override {
     PrefServiceFactory factory;
     factory.set_user_prefs(make_scoped_refptr(new PrefStoreStub()));
     local_state_ = factory.Create(new PrefRegistrySimple());
     WizardController::set_local_state_for_testing(local_state_.get());
 
     WizardControllerTest::SetUpOnMainThread();
 
     // Make sure that OOBE is run as an "official" build.
     WizardController::default_controller()->is_official_build_ = true;
   }
 
   FakeSessionManagerClient* fake_session_manager_client() const {
     return fake_session_manager_client_;
   }
 
  private:
-  scoped_ptr<PrefService> local_state_;
+  std::unique_ptr<PrefService> local_state_;
   FakeSessionManagerClient* fake_session_manager_client_;
 
   DISALLOW_COPY_AND_ASSIGN(WizardControllerBrokenLocalStateTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerBrokenLocalStateTest,
                        LocalStateCorrupted) {
   // Checks that after wizard controller initialization error screen
   // in the proper state is displayed.
   ASSERT_EQ(GetErrorScreen(),
@@ skipping 283 matching lines @@
 // TODO(merkulova): Add tests for bluetooth HID detection screen variations when
 // UI and logic is ready. http://crbug.com/127016
 
 // TODO(dzhioev): Add tests for controller/host pairing flow.
 // http://crbug.com/375191
 
 static_assert(BaseScreenDelegate::EXIT_CODES_COUNT == 23,
               "tests for new control flow are missing");
 
 }  // namespace chromeos