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

chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_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/policy/user_cloud_policy_manager_factory_chromeos.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 68 matching lines @@
 }
 
 // static
 UserCloudPolicyManagerChromeOS*
     UserCloudPolicyManagerFactoryChromeOS::GetForProfile(
         Profile* profile) {
   return GetInstance()->GetManagerForProfile(profile);
 }
 
 // static
-scoped_ptr<UserCloudPolicyManagerChromeOS>
-    UserCloudPolicyManagerFactoryChromeOS::CreateForProfile(
-        Profile* profile,
-        bool force_immediate_load,
-        scoped_refptr<base::SequencedTaskRunner> background_task_runner) {
+std::unique_ptr<UserCloudPolicyManagerChromeOS>
+UserCloudPolicyManagerFactoryChromeOS::CreateForProfile(
+    Profile* profile,
+    bool force_immediate_load,
+    scoped_refptr<base::SequencedTaskRunner> background_task_runner) {
   return GetInstance()->CreateManagerForProfile(
       profile, force_immediate_load, background_task_runner);
 }
 
 UserCloudPolicyManagerFactoryChromeOS::UserCloudPolicyManagerFactoryChromeOS()
     : BrowserContextKeyedBaseFactory(
         "UserCloudPolicyManagerChromeOS",
         BrowserContextDependencyManager::GetInstance()) {
   DependsOn(SchemaRegistryServiceFactory::GetInstance());
 }
 
 UserCloudPolicyManagerFactoryChromeOS::
     ~UserCloudPolicyManagerFactoryChromeOS() {}
 
 UserCloudPolicyManagerChromeOS*
     UserCloudPolicyManagerFactoryChromeOS::GetManagerForProfile(
         Profile* profile) {
   // Get the manager for the original profile, since the PolicyService is
   // also shared between the incognito Profile and the original Profile.
   ManagerMap::const_iterator it = managers_.find(profile->GetOriginalProfile());
   return it != managers_.end() ? it->second : NULL;
 }
 
-scoped_ptr<UserCloudPolicyManagerChromeOS>
-    UserCloudPolicyManagerFactoryChromeOS::CreateManagerForProfile(
-        Profile* profile,
-        bool force_immediate_load,
-        scoped_refptr<base::SequencedTaskRunner> background_task_runner) {
+std::unique_ptr<UserCloudPolicyManagerChromeOS>
+UserCloudPolicyManagerFactoryChromeOS::CreateManagerForProfile(
+    Profile* profile,
+    bool force_immediate_load,
+    scoped_refptr<base::SequencedTaskRunner> background_task_runner) {
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
   // Don't initialize cloud policy for the signin profile.
   if (chromeos::ProfileHelper::IsSigninProfile(profile))
-    return scoped_ptr<UserCloudPolicyManagerChromeOS>();
+    return std::unique_ptr<UserCloudPolicyManagerChromeOS>();
 
   // |user| should never be NULL except for the signin profile. This object is
   // created as part of the Profile creation, which happens right after
   // sign-in. The just-signed-in User is the active user during that time.
   const user_manager::User* user =
       chromeos::ProfileHelper::Get()->GetUserByProfile(profile);
   CHECK(user);
 
   // User policy exists for enterprise accounts only:
   // - For regular enterprise users (those who have a GAIA account), a
   //   |UserCloudPolicyManagerChromeOS| is created here.
   // - For device-local accounts, policy is provided by
   //   |DeviceLocalAccountPolicyService|.
   // All other user types do not have user policy.
   const AccountId account_id = user->GetAccountId();
   if (!user->HasGaiaAccount() || user->IsSupervised() ||
       BrowserPolicyConnector::IsNonEnterpriseUser(account_id.GetUserEmail())) {
-    return scoped_ptr<UserCloudPolicyManagerChromeOS>();
+    return std::unique_ptr<UserCloudPolicyManagerChromeOS>();
   }
 
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   const bool is_browser_restart =
       command_line->HasSwitch(chromeos::switches::kLoginUser);
   const user_manager::UserManager* const user_manager =
       user_manager::UserManager::Get();
 
   // We want to block for policy in a few situations: if the user is new, or
@@ skipping 28 matching lines @@
   const base::FilePath legacy_dir = profile_dir.Append(kDeviceManagementDir);
   const base::FilePath policy_cache_file = legacy_dir.Append(kPolicy);
   const base::FilePath token_cache_file = legacy_dir.Append(kToken);
   const base::FilePath component_policy_cache_dir =
       profile_dir.Append(kPolicy).Append(kComponentsDir);
   const base::FilePath external_data_dir =
         profile_dir.Append(kPolicy).Append(kPolicyExternalDataDir);
   base::FilePath policy_key_dir;
   CHECK(PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &policy_key_dir));
 
-  scoped_ptr<UserCloudPolicyStoreChromeOS> store(
+  std::unique_ptr<UserCloudPolicyStoreChromeOS> store(
       new UserCloudPolicyStoreChromeOS(
           chromeos::DBusThreadManager::Get()->GetCryptohomeClient(),
           chromeos::DBusThreadManager::Get()->GetSessionManagerClient(),
           background_task_runner, account_id, policy_key_dir, token_cache_file,
           policy_cache_file));
 
   scoped_refptr<base::SequencedTaskRunner> backend_task_runner =
       content::BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
           content::BrowserThread::GetBlockingPool()->GetSequenceToken());
   scoped_refptr<base::SequencedTaskRunner> io_task_runner =
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::IO);
-  scoped_ptr<CloudExternalDataManager> external_data_manager(
+  std::unique_ptr<CloudExternalDataManager> external_data_manager(
       new UserCloudExternalDataManager(base::Bind(&GetChromePolicyDetails),
-                                       backend_task_runner,
-                                       io_task_runner,
-                                       external_data_dir,
-                                       store.get()));
+                                       backend_task_runner, io_task_runner,
+                                       external_data_dir, store.get()));
   if (force_immediate_load)
     store->LoadImmediately();
 
   scoped_refptr<base::SequencedTaskRunner> file_task_runner =
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::FILE);
 
-  scoped_ptr<UserCloudPolicyManagerChromeOS> manager(
+  std::unique_ptr<UserCloudPolicyManagerChromeOS> manager(
       new UserCloudPolicyManagerChromeOS(
           std::move(store), std::move(external_data_manager),
           component_policy_cache_dir, wait_for_policy_fetch,
           initial_policy_fetch_timeout, base::ThreadTaskRunnerHandle::Get(),
           file_task_runner, io_task_runner));
 
   bool wildcard_match = false;
   if (connector->IsEnterpriseManaged() &&
       chromeos::CrosSettings::IsWhitelisted(account_id.GetUserEmail(),
                                             &wildcard_match) &&
@@ skipping 34 matching lines @@
 
 bool UserCloudPolicyManagerFactoryChromeOS::HasTestingFactory(
     content::BrowserContext* context) {
   return false;
 }
 
 void UserCloudPolicyManagerFactoryChromeOS::CreateServiceNow(
     content::BrowserContext* context) {}
 
 }  // namespace policy