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

chrome/browser/chromeos/chrome_browser_main_chromeos.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/chrome_browser_main_chromeos.h"
 
 #include <stddef.h>
+
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/linux_util.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #include "chrome/browser/chromeos/accessibility/magnification_manager.h"
@@ skipping 181 matching lines @@
     bluez::BluezDBusManager::Initialize(
         DBusThreadManager::Get()->GetSystemBus(),
         chromeos::DBusThreadManager::Get()->IsUsingStub(
             chromeos::DBusClientBundle::BLUETOOTH));
 
     PowerPolicyController::Initialize(
         DBusThreadManager::Get()->GetPowerManagerClient());
 
     ScopedVector<CrosDBusService::ServiceProviderInterface> service_providers;
     service_providers.push_back(ProxyResolutionServiceProvider::Create(
-        make_scoped_ptr(new ChromeProxyResolverDelegate())));
+        base::WrapUnique(new ChromeProxyResolverDelegate())));
     service_providers.push_back(new DisplayPowerServiceProvider(
-        make_scoped_ptr(new ChromeDisplayPowerServiceProviderDelegate)));
+        base::WrapUnique(new ChromeDisplayPowerServiceProviderDelegate)));
     service_providers.push_back(new LivenessServiceProvider);
     service_providers.push_back(new ScreenLockServiceProvider);
     service_providers.push_back(new ConsoleServiceProvider(
-        make_scoped_ptr(new ChromeConsoleServiceProviderDelegate)));
+        base::WrapUnique(new ChromeConsoleServiceProviderDelegate)));
     service_providers.push_back(new KioskInfoService);
     CrosDBusService::Initialize(std::move(service_providers));
 
     // Initialize PowerDataCollector after DBusThreadManager is initialized.
     PowerDataCollector::Initialize();
 
     LoginState::Initialize();
     SystemSaltGetter::Initialize();
     TPMTokenLoader::Initialize();
     CertLoader::Initialize();
@@ skipping 42 matching lines @@
     PowerDataCollector::Shutdown();
     PowerPolicyController::Shutdown();
     device::BluetoothAdapterFactory::Shutdown();
     bluez::BluezDBusManager::Shutdown();
 
     // NOTE: This must only be called if Initialize() was called.
     DBusThreadManager::Shutdown();
   }
 
  private:
-  scoped_ptr<NetworkConnectDelegateChromeOS> network_connect_delegate_;
+  std::unique_ptr<NetworkConnectDelegateChromeOS> network_connect_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(DBusServices);
 };
 
 }  //  namespace internal
 
 // ChromeBrowserMainPartsChromeos ----------------------------------------------
 
 ChromeBrowserMainPartsChromeos::ChromeBrowserMainPartsChromeos(
     const content::MainFunctionParams& parameters)
@@ skipping 92 matching lines @@
 
   // Set the crypto thread after the IO thread has been created/started.
   TPMTokenLoader::Get()->SetCryptoTaskRunner(
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::IO));
 
   CrasAudioHandler::Initialize(
       new AudioDevicesPrefHandlerImpl(g_browser_process->local_state()));
 
   quirks::QuirksManager::Initialize(
-      scoped_ptr<quirks::QuirksManager::Delegate>(
+      std::unique_ptr<quirks::QuirksManager::Delegate>(
           new quirks::QuirksManagerDelegateImpl()),
       content::BrowserThread::GetBlockingPool(),
       g_browser_process->local_state(),
       g_browser_process->system_request_context());
 
   // Start loading machine statistics here. StatisticsProvider::Shutdown()
   // will ensure that loading is aborted on early exit.
   bool load_oem_statistics = !StartupUtils::IsOobeCompleted();
   system::StatisticsProvider::GetInstance()->StartLoadingMachineStatistics(
       content::BrowserThread::GetMessageLoopProxyForThread(
@@ skipping 137 matching lines @@
             << " with hash: " << user_id_hash;
   }
 }
 
 class GuestLanguageSetCallbackData {
  public:
   explicit GuestLanguageSetCallbackData(Profile* profile) : profile(profile) {
   }
 
   // Must match SwitchLanguageCallback type.
-  static void Callback(const scoped_ptr<GuestLanguageSetCallbackData>& self,
-                       const locale_util::LanguageSwitchResult& result);
+  static void Callback(
+      const std::unique_ptr<GuestLanguageSetCallbackData>& self,
+      const locale_util::LanguageSwitchResult& result);
 
   Profile* profile;
 };
 
 // static
 void GuestLanguageSetCallbackData::Callback(
-    const scoped_ptr<GuestLanguageSetCallbackData>& self,
+    const std::unique_ptr<GuestLanguageSetCallbackData>& self,
     const locale_util::LanguageSwitchResult& result) {
   input_method::InputMethodManager* manager =
       input_method::InputMethodManager::Get();
   scoped_refptr<input_method::InputMethodManager::State> ime_state =
       manager->GetActiveIMEState();
   // For guest mode, we should always use the first login input methods.
   // This is to keep consistency with UserSessionManager::SetFirstLoginPrefs().
   // See crbug.com/530808.
   std::vector<std::string> input_methods;
   manager->GetInputMethodUtil()->GetFirstLoginInputMethodIds(
@@ skipping 19 matching lines @@
   }
 
   // Finally, activate the first login input method.
   const std::vector<std::string>& login_input_methods =
       manager->GetInputMethodUtil()->GetHardwareLoginInputMethodIds();
   ime_state->ChangeInputMethod(login_input_methods[0],
                                false /* show_message */);
 }
 
 void SetGuestLocale(Profile* const profile) {
-  scoped_ptr<GuestLanguageSetCallbackData> data(
+  std::unique_ptr<GuestLanguageSetCallbackData> data(
       new GuestLanguageSetCallbackData(profile));
   locale_util::SwitchLanguageCallback callback(base::Bind(
       &GuestLanguageSetCallbackData::Callback, base::Passed(std::move(data))));
   const user_manager::User* const user =
       ProfileHelper::Get()->GetUserByProfile(profile);
   UserSessionManager::GetInstance()->RespectLocalePreference(
       profile, user, callback);
 }
 
 void ChromeBrowserMainPartsChromeos::PostProfileInit() {
@@ skipping 47 matching lines @@
   g_browser_process->platform_part()->SessionManager()->Start();
 
   // Guest user profile is never initialized with locale settings,
   // so we need special handling for Guest session.
   if (user_manager::UserManager::Get()->IsLoggedInAsGuest())
     SetGuestLocale(profile());
 
   peripheral_battery_observer_.reset(new PeripheralBatteryObserver());
 
   renderer_freezer_.reset(
-      new RendererFreezer(scoped_ptr<RendererFreezer::Delegate>(
+      new RendererFreezer(std::unique_ptr<RendererFreezer::Delegate>(
           new FreezerCgroupProcessManager())));
 
   g_browser_process->platform_part()->InitializeAutomaticRebootManager();
   g_browser_process->platform_part()->InitializeDeviceDisablingManager();
 
   // This observer cannot be created earlier because it requires the shell to be
   // available.
   idle_action_warning_observer_.reset(new IdleActionWarningObserver());
 
   ChromeBrowserMainPartsLinux::PostProfileInit();
@@ skipping 46 matching lines @@
     // These are dependent on the ash::Shell singleton already having been
     // initialized. Consequently, these cannot be used when running as a mus
     // client.
     // TODO(oshima): Remove ash dependency in PowerButtonObserver.
     // crbug.com/408832.
     power_button_observer_.reset(new PowerButtonObserver);
     data_promo_notification_.reset(new DataPromoNotification());
 
     keyboard_event_rewriters_.reset(new EventRewriterController());
     keyboard_event_rewriters_->AddEventRewriter(
-        scoped_ptr<ui::EventRewriter>(new KeyboardDrivenEventRewriter()));
+        std::unique_ptr<ui::EventRewriter>(new KeyboardDrivenEventRewriter()));
     keyboard_event_rewriters_->AddEventRewriter(
-        scoped_ptr<ui::EventRewriter>(new SpokenFeedbackEventRewriter()));
+        std::unique_ptr<ui::EventRewriter>(new SpokenFeedbackEventRewriter()));
     keyboard_event_rewriters_->AddEventRewriter(
-        scoped_ptr<ui::EventRewriter>(new EventRewriter(
+        std::unique_ptr<ui::EventRewriter>(new EventRewriter(
             ash::Shell::GetInstance()->sticky_keys_controller())));
     keyboard_event_rewriters_->Init();
   }
 
   ChromeBrowserMainPartsLinux::PostBrowserStart();
 }
 
 // Shut down services before the browser process, etc are destroyed.
 void ChromeBrowserMainPartsChromeos::PostMainMessageLoopRun() {
   chromeos::ResourceReporter::GetInstance()->StopMonitoring();
@@ skipping 113 matching lines @@
   // Destroy DBus services immediately after threads are stopped.
   dbus_services_.reset();
 
   ChromeBrowserMainPartsLinux::PostDestroyThreads();
 
   // Destroy DeviceSettingsService after g_browser_process.
   DeviceSettingsService::Shutdown();
 }
 
 }  //  namespace chromeos