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

chrome/browser/chromeos/policy/device_local_account_policy_service.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/policy/device_local_account_policy_service.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 36 matching lines @@
 #include "url/gurl.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 // Creates and initializes a cloud policy client. Returns nullptr if the device
 // is not enterprise-enrolled.
-scoped_ptr<CloudPolicyClient> CreateClient(
+std::unique_ptr<CloudPolicyClient> CreateClient(
     chromeos::DeviceSettingsService* device_settings_service,
     DeviceManagementService* device_management_service,
     scoped_refptr<net::URLRequestContextGetter> system_request_context) {
   const em::PolicyData* policy_data = device_settings_service->policy_data();
   if (!policy_data ||
       GetManagementMode(*policy_data) != MANAGEMENT_MODE_ENTERPRISE_MANAGED ||
       !device_management_service) {
-    return scoped_ptr<CloudPolicyClient>();
+    return std::unique_ptr<CloudPolicyClient>();
   }
 
   scoped_refptr<net::URLRequestContextGetter> request_context =
       new SystemPolicyRequestContext(
           system_request_context, GetUserAgent());
 
-  scoped_ptr<CloudPolicyClient> client(
-      new CloudPolicyClient(std::string(), std::string(),
-                            kPolicyVerificationKeyHash,
-                            device_management_service, request_context));
+  std::unique_ptr<CloudPolicyClient> client(new CloudPolicyClient(
+      std::string(), std::string(), kPolicyVerificationKeyHash,
+      device_management_service, request_context));
   client->SetupRegistration(policy_data->request_token(),
                             policy_data->device_id());
   return client;
 }
 
 // Get the subdirectory of the force-installed extension cache and the component
 // policy cache used for |account_id|.
 std::string GetCacheSubdirectoryForAccountID(const std::string& account_id) {
   return base::HexEncode(account_id.c_str(), account_id.size());
 }
@@ skipping 26 matching lines @@
       GetCacheSubdirectoryForAccountID(account_id_to_delete));
   if (base::DirectoryExists(path))
     base::DeleteFile(path, true);
 }
 
 }  // namespace
 
 DeviceLocalAccountPolicyBroker::DeviceLocalAccountPolicyBroker(
     const DeviceLocalAccount& account,
     const base::FilePath& component_policy_cache_path,
-    scoped_ptr<DeviceLocalAccountPolicyStore> store,
+    std::unique_ptr<DeviceLocalAccountPolicyStore> store,
     scoped_refptr<DeviceLocalAccountExternalDataManager> external_data_manager,
     const base::Closure& policy_update_callback,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     AffiliatedInvalidationServiceProvider* invalidation_service_provider)
     : invalidation_service_provider_(invalidation_service_provider),
       account_id_(account.account_id),
       user_id_(account.user_id),
       component_policy_cache_path_(component_policy_cache_path),
       store_(std::move(store)),
       extension_tracker_(account, store_.get(), &schema_registry_),
@@ skipping 35 matching lines @@
   return invalidator_ != nullptr;
 }
 
 void DeviceLocalAccountPolicyBroker::ConnectIfPossible(
     chromeos::DeviceSettingsService* device_settings_service,
     DeviceManagementService* device_management_service,
     scoped_refptr<net::URLRequestContextGetter> request_context) {
   if (core_.client())
     return;
 
-  scoped_ptr<CloudPolicyClient> client(CreateClient(device_settings_service,
-                                                    device_management_service,
-                                                    request_context));
+  std::unique_ptr<CloudPolicyClient> client(CreateClient(
+      device_settings_service, device_management_service, request_context));
   if (!client)
     return;
 
   CreateComponentCloudPolicyService(request_context, client.get());
   core_.Connect(std::move(client));
   external_data_manager_->Connect(request_context);
   core_.StartRefreshScheduler();
   UpdateRefreshDelay();
   invalidator_.reset(new AffiliatedCloudPolicyInvalidator(
       em::DeviceRegisterRequest::DEVICE,
@@ skipping 35 matching lines @@
 
 void DeviceLocalAccountPolicyBroker::CreateComponentCloudPolicyService(
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
     CloudPolicyClient* client) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableComponentCloudPolicy)) {
     // Disabled via the command line.
     return;
   }
 
-  scoped_ptr<ResourceCache> resource_cache(
+  std::unique_ptr<ResourceCache> resource_cache(
       new ResourceCache(component_policy_cache_path_,
                         content::BrowserThread::GetMessageLoopProxyForThread(
                             content::BrowserThread::FILE)));
 
   component_policy_service_.reset(new ComponentCloudPolicyService(
       this, &schema_registry_, core(), client, std::move(resource_cache),
       request_context, content::BrowserThread::GetMessageLoopProxyForThread(
                            content::BrowserThread::FILE),
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::IO)));
@@ skipping 191 matching lines @@
   PolicyBrokerMap old_policy_brokers;
   policy_brokers_.swap(old_policy_brokers);
   std::set<std::string> subdirectories_to_keep;
   const std::vector<DeviceLocalAccount> device_local_accounts =
       GetDeviceLocalAccounts(cros_settings_);
   for (std::vector<DeviceLocalAccount>::const_iterator it =
            device_local_accounts.begin();
        it != device_local_accounts.end(); ++it) {
     PolicyBrokerMap::iterator broker_it = old_policy_brokers.find(it->user_id);
 
-    scoped_ptr<DeviceLocalAccountPolicyBroker> broker;
+    std::unique_ptr<DeviceLocalAccountPolicyBroker> broker;
     bool broker_initialized = false;
     if (broker_it != old_policy_brokers.end()) {
       // Reuse the existing broker if present.
       broker.reset(broker_it->second);
       old_policy_brokers.erase(broker_it);
       broker_initialized = true;
     } else {
-      scoped_ptr<DeviceLocalAccountPolicyStore> store(
-          new DeviceLocalAccountPolicyStore(it->account_id,
-                                            session_manager_client_,
-                                            device_settings_service_,
-                                            store_background_task_runner_));
+      std::unique_ptr<DeviceLocalAccountPolicyStore> store(
+          new DeviceLocalAccountPolicyStore(
+              it->account_id, session_manager_client_, device_settings_service_,
+              store_background_task_runner_));
       scoped_refptr<DeviceLocalAccountExternalDataManager>
           external_data_manager =
               external_data_service_->GetExternalDataManager(it->account_id,
                                                              store.get());
       broker.reset(new DeviceLocalAccountPolicyBroker(
           *it, component_policy_cache_root_.Append(
                    GetCacheSubdirectoryForAccountID(it->account_id)),
           std::move(store), external_data_manager,
           base::Bind(&DeviceLocalAccountPolicyService::NotifyPolicyUpdated,
                      base::Unretained(this), it->user_id),
@@ skipping 95 matching lines @@
   }
   return nullptr;
 }
 
 void DeviceLocalAccountPolicyService::NotifyPolicyUpdated(
     const std::string& user_id) {
   FOR_EACH_OBSERVER(Observer, observers_, OnPolicyUpdated(user_id));
 }
 
 }  // namespace policy