Convert Pass()→std::move() in //chrome/browser/chromeos/policy

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"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 50 matching lines @@
   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));
   client->SetupRegistration(policy_data->request_token(),
                             policy_data->device_id());
-  return client.Pass();
+  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());
 }
 
 // Cleans up the cache directory by removing subdirectories that are not found
 // in |subdirectories_to_keep|. Only caches whose cache directory is found in
@@ skipping 32 matching lines @@
     const base::FilePath& component_policy_cache_path,
     scoped_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_(store.Pass()),
+      store_(std::move(store)),
       extension_tracker_(account, store_.get(), &schema_registry_),
       external_data_manager_(external_data_manager),
       core_(dm_protocol::kChromePublicAccountPolicyType,
             store_->account_id(),
             store_.get(),
             task_runner),
       policy_update_callback_(policy_update_callback) {
   base::FilePath cache_root_dir;
   CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_EXTENSIONS,
                          &cache_root_dir));
@@ skipping 33 matching lines @@
   if (core_.client())
     return;
 
   scoped_ptr<CloudPolicyClient> client(CreateClient(device_settings_service,
                                                     device_management_service,
                                                     request_context));
   if (!client)
     return;
 
   CreateComponentCloudPolicyService(request_context, client.get());
-  core_.Connect(client.Pass());
+  core_.Connect(std::move(client));
   external_data_manager_->Connect(request_context);
   core_.StartRefreshScheduler();
   UpdateRefreshDelay();
   invalidator_.reset(new AffiliatedCloudPolicyInvalidator(
       em::DeviceRegisterRequest::DEVICE,
       &core_,
       invalidation_service_provider_));
 }
 
 void DeviceLocalAccountPolicyBroker::UpdateRefreshDelay() {
@@ skipping 36 matching lines @@
     // Disabled via the command line.
     return;
   }
 
   scoped_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,
-      resource_cache.Pass(),
-      request_context,
-      content::BrowserThread::GetMessageLoopProxyForThread(
-          content::BrowserThread::FILE),
+      this, &schema_registry_, core(), client, std::move(resource_cache),
+      request_context, content::BrowserThread::GetMessageLoopProxyForThread(
+                           content::BrowserThread::FILE),
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::IO)));
 }
 
 DeviceLocalAccountPolicyService::DeviceLocalAccountPolicyService(
     chromeos::SessionManagerClient* session_manager_client,
     chromeos::DeviceSettingsService* device_settings_service,
     chromeos::CrosSettings* cros_settings,
     AffiliatedInvalidationServiceProvider* invalidation_service_provider,
     scoped_refptr<base::SequencedTaskRunner> store_background_task_runner,
@@ skipping 201 matching lines @@
       scoped_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)),
-          store.Pass(),
-          external_data_manager,
+          *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),
-          base::ThreadTaskRunnerHandle::Get(),
-          invalidation_service_provider_));
+                     base::Unretained(this), it->user_id),
+          base::ThreadTaskRunnerHandle::Get(), invalidation_service_provider_));
     }
 
     // Fire up the cloud connection for fetching policy for the account from
     // the cloud if this is an enterprise-managed device.
     broker->ConnectIfPossible(device_settings_service_,
                               device_management_service_,
                               request_context_);
 
     policy_brokers_[it->user_id] = broker.release();
     if (!broker_initialized) {
@@ skipping 84 matching lines @@
   }
   return nullptr;
 }
 
 void DeviceLocalAccountPolicyService::NotifyPolicyUpdated(
     const std::string& user_id) {
   FOR_EACH_OBSERVER(Observer, observers_, OnPolicyUpdated(user_id));
 }
 
 }  // namespace policy