Convert Pass()→std::move() in //components/[n-z]*

components/policy/core/common/cloud/user_cloud_policy_store.cc

 // Copyright 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 "components/policy/core/common/cloud/user_cloud_policy_store.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/task_runner_util.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "policy/proto/cloud_policy.pb.h"
 #include "policy/proto/device_management_backend.pb.h"
 #include "policy/proto/policy_signing_key.pb.h"
@@ skipping 245 matching lines @@
         // The cached key didn't match our current key, so we're doing a key
         // rotation - make sure we request a new key from the server on our
         // next fetch.
         doing_key_rotation = true;
         DLOG(WARNING) << "Verification key rotation detected";
         // TODO(atwilson): Add code to update |verification_key| to point to
         // the correct key to validate the existing blob (can't do this until
         // we've done our first key rotation).
       }
 
-      Validate(cloud_policy.Pass(),
-               key.Pass(),
-               verification_key,
-               validate_in_background,
-               base::Bind(
-                   &UserCloudPolicyStore::InstallLoadedPolicyAfterValidation,
-                   weak_factory_.GetWeakPtr(),
-                   doing_key_rotation,
-                   result.key.has_signing_key() ?
-                       result.key.signing_key() : std::string()));
+      Validate(
+          std::move(cloud_policy), std::move(key), verification_key,
+          validate_in_background,
+          base::Bind(&UserCloudPolicyStore::InstallLoadedPolicyAfterValidation,
+                     weak_factory_.GetWeakPtr(), doing_key_rotation,
+                     result.key.has_signing_key() ? result.key.signing_key()
+                                                  : std::string()));
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void UserCloudPolicyStore::InstallLoadedPolicyAfterValidation(
     bool doing_key_rotation,
     const std::string& signing_key,
@@ skipping 17 matching lines @@
   // If we're doing a key rotation, clear the public key version so a future
   // policy fetch will force regeneration of the keys.
   if (doing_key_rotation) {
     validator->policy_data()->clear_public_key_version();
     policy_key_.clear();
   } else {
     // Policy validation succeeded, so we know the signing key is good.
     policy_key_ = signing_key;
   }
 
-  InstallPolicy(validator->policy_data().Pass(), validator->payload().Pass());
+  InstallPolicy(std::move(validator->policy_data()),
+                std::move(validator->payload()));
   status_ = STATUS_OK;
   NotifyStoreLoaded();
 }
 
 void UserCloudPolicyStore::Store(const em::PolicyFetchResponse& policy) {
   // Stop any pending requests to store policy, then validate the new policy
   // before storing it.
   weak_factory_.InvalidateWeakPtrs();
   scoped_ptr<em::PolicyFetchResponse> policy_copy(
       new em::PolicyFetchResponse(policy));
-  Validate(policy_copy.Pass(),
-           scoped_ptr<em::PolicySigningKey>(),
-           verification_key_,
-           true,
+  Validate(std::move(policy_copy), scoped_ptr<em::PolicySigningKey>(),
+           verification_key_, true,
            base::Bind(&UserCloudPolicyStore::StorePolicyAfterValidation,
                       weak_factory_.GetWeakPtr()));
 }
 
 void UserCloudPolicyStore::Validate(
     scoped_ptr<em::PolicyFetchResponse> policy,
     scoped_ptr<em::PolicySigningKey> cached_key,
     const std::string& verification_key,
     bool validate_in_background,
     const UserCloudPolicyValidator::CompletionCallback& callback) {
   // Configure the validator.
   scoped_ptr<UserCloudPolicyValidator> validator = CreateValidator(
-      policy.Pass(),
-      CloudPolicyValidatorBase::TIMESTAMP_NOT_BEFORE);
+      std::move(policy), CloudPolicyValidatorBase::TIMESTAMP_NOT_BEFORE);
 
   // Extract the owning domain from the signed-in user (if any is set yet).
   // If there's no owning domain, then the code just ensures that the policy
   // is self-consistent (that the keys are signed with the same domain that the
   // username field in the policy contains). UserPolicySigninServerBase will
   // verify that the username matches the signed in user once profile
   // initialization is complete (http://crbug.com/342327).
   std::string owning_domain;
 
   // Validate the username if the user is signed in. The signin_username_ can
@@ skipping 85 matching lines @@
     return;
   }
 
   // Persist the validated policy (just fire a task - don't bother getting a
   // reply because we can't do anything if it fails).
   background_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&StorePolicyToDiskOnBackgroundThread,
                  policy_path_, key_path_, verification_key_,
                  *validator->policy()));
-  InstallPolicy(validator->policy_data().Pass(), validator->payload().Pass());
+  InstallPolicy(std::move(validator->policy_data()),
+                std::move(validator->payload()));
 
   // If the key was rotated, update our local cache of the key.
   if (validator->policy()->has_new_public_key())
     policy_key_ = validator->policy()->new_public_key();
   status_ = STATUS_OK;
   NotifyStoreLoaded();
 }
 
 }  // namespace policy