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

chrome/browser/chromeos/system/automatic_reboot_manager_unittest.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 "chrome/browser/chromeos/system/automatic_reboot_manager.h"
 
 #include <string>
 
 #include "ash/shell.h"
 #include "ash/test/test_shell_delegate.h"
@@ skipping 88 matching lines @@
   }
 
  private:
   ~TestAutomaticRebootManagerTaskRunner() override;
 
   // base::TestMockTimeTaskRunner:
   void OnBeforeSelectingTask() override;
   void OnAfterTimePassed() override;
   void OnAfterTaskRun() override;
 
-  scoped_ptr<MockUptimeProvider> uptime_provider_;
+  std::unique_ptr<MockUptimeProvider> uptime_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutomaticRebootManagerTaskRunner);
 };
 
 class MockAutomaticRebootManagerObserver
     : public AutomaticRebootManagerObserver {
  public:
   MockAutomaticRebootManagerObserver();
   ~MockAutomaticRebootManagerObserver() override;
 
@@ skipping 59 matching lines @@
   // has increased by a small offset already. The offset is calculated and
   // stored in |uptime_processing_delay_| so that tests can accurately determine
   // the uptime seen by the UI thread.
   base::TimeDelta uptime_processing_delay_;
   base::TimeDelta update_reboot_needed_uptime_;
   base::TimeDelta uptime_limit_;
 
   scoped_refptr<TestAutomaticRebootManagerTaskRunner> task_runner_;
 
   MockAutomaticRebootManagerObserver automatic_reboot_manager_observer_;
-  scoped_ptr<AutomaticRebootManager> automatic_reboot_manager_;
+  std::unique_ptr<AutomaticRebootManager> automatic_reboot_manager_;
 
  private:
   void VerifyTimerIsStopped(const base::OneShotTimer* timer) const;
   void VerifyTimerIsRunning(const base::OneShotTimer* timer,
                             const base::TimeDelta& delay) const;
   void VerifyLoginScreenIdleTimerIsRunning() const;
 
   base::ScopedTempDir temp_dir_;
   base::FilePath update_reboot_needed_uptime_file_;
 
@@ skipping 126 matching lines @@
   update_reboot_needed_uptime_file_ =
       temp_dir.Append("update_reboot_needed_uptime");
   ASSERT_FALSE(base::WriteFile(update_reboot_needed_uptime_file_, NULL, 0));
   ASSERT_TRUE(PathService::Override(chromeos::FILE_UPTIME, uptime_file));
   ASSERT_TRUE(PathService::Override(chromeos::FILE_UPDATE_REBOOT_NEEDED_UPTIME,
                                     update_reboot_needed_uptime_file_));
 
   TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_);
   AutomaticRebootManager::RegisterPrefs(local_state_.registry());
 
-  scoped_ptr<DBusThreadManagerSetter> dbus_setter =
+  std::unique_ptr<DBusThreadManagerSetter> dbus_setter =
       chromeos::DBusThreadManager::GetSetterForTesting();
   power_manager_client_ = new FakePowerManagerClient;
   dbus_setter->SetPowerManagerClient(
-      scoped_ptr<PowerManagerClient>(power_manager_client_));
+      std::unique_ptr<PowerManagerClient>(power_manager_client_));
   update_engine_client_ = new FakeUpdateEngineClient;
   dbus_setter->SetUpdateEngineClient(
-      scoped_ptr<UpdateEngineClient>(update_engine_client_));
+      std::unique_ptr<UpdateEngineClient>(update_engine_client_));
 
   EXPECT_CALL(*mock_user_manager_, IsUserLoggedIn())
      .WillRepeatedly(ReturnPointee(&is_user_logged_in_));
   EXPECT_CALL(*mock_user_manager_, IsLoggedInAsKioskApp())
      .WillRepeatedly(ReturnPointee(&is_logged_in_as_kiosk_app_));
 }
 
 void AutomaticRebootManagerBasicTest::TearDown() {
   if (automatic_reboot_manager_) {
     Mock::VerifyAndClearExpectations(&automatic_reboot_manager_observer_);
@@ skipping 99 matching lines @@
   Mock::VerifyAndClearExpectations(&automatic_reboot_manager_observer_);
   EXPECT_CALL(automatic_reboot_manager_observer_,
               WillDestroyAutomaticRebootManager()).Times(0);
   EXPECT_CALL(automatic_reboot_manager_observer_,
               OnRebootRequested(_)).Times(0);
 }
 
 void AutomaticRebootManagerBasicTest::CreateAutomaticRebootManager(
     bool expect_reboot) {
   automatic_reboot_manager_.reset(new AutomaticRebootManager(
-      scoped_ptr<base::TickClock>(task_runner_->GetMockTickClock())));
+      std::unique_ptr<base::TickClock>(task_runner_->GetMockTickClock())));
   automatic_reboot_manager_observer_.Init(automatic_reboot_manager_.get());
   task_runner_->RunUntilIdle();
   EXPECT_EQ(expect_reboot ? 1 : 0,
             power_manager_client_->num_request_restart_calls());
 
   uptime_processing_delay_ =
       base::TimeTicks() - automatic_reboot_manager_->boot_time_ -
       uptime_provider()->uptime();
   EXPECT_GE(uptime_processing_delay_, base::TimeDelta());
   EXPECT_LE(uptime_processing_delay_, base::TimeDelta::FromSeconds(1));
@@ skipping 1806 matching lines @@
 INSTANTIATE_TEST_CASE_P(
     AutomaticRebootManagerTestInstance,
     AutomaticRebootManagerTest,
     ::testing::Values(
         AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_LOGIN_SCREEN,
         AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_KIOSK_APP_SESSION,
         AUTOMATIC_REBOOT_MANAGER_TEST_SCENARIO_NON_KIOSK_APP_SESSION));
 
 }  // namespace system
 }  // namespace chromeos