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

components/policy/core/common/cloud/component_cloud_policy_store.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 "components/policy/core/common/cloud/component_cloud_policy_store.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_validator.h"
 #include "components/policy/core/common/external_data_fetcher.h"
@@ skipping 112 matching lines @@
     ContentMap protos;
     cache_->LoadAllSubkeys(constants.proto_cache_key, &protos);
     for (ContentMap::iterator it = protos.begin(); it != protos.end(); ++it) {
       const std::string& id(it->first);
       PolicyNamespace ns(constants.domain, id);
 
       // Validate each protobuf.
       scoped_ptr<em::PolicyFetchResponse> proto(new em::PolicyFetchResponse);
       em::ExternalPolicyData payload;
       if (!proto->ParseFromString(it->second) ||
-          !ValidateProto(
-              proto.Pass(), constants.policy_type, id, &payload, NULL)) {
+          !ValidateProto(std::move(proto), constants.policy_type, id, &payload,
+                         NULL)) {
         Delete(ns);
         continue;
       }
 
       // The protobuf looks good; load the policy data.
       std::string data;
       PolicyMap policy;
       if (cache_->Load(constants.data_cache_key, id, &data) &&
           ValidateData(data, payload.secure_hash(), &policy)) {
         // The data is also good; expose the policies.
@@ skipping 94 matching lines @@
     policy_bundle_.Clear();
     delegate_->OnComponentCloudPolicyStoreUpdated();
   }
 }
 
 bool ComponentCloudPolicyStore::ValidatePolicy(
     scoped_ptr<em::PolicyFetchResponse> proto,
     PolicyNamespace* ns,
     em::ExternalPolicyData* payload) {
   em::PolicyData policy_data;
-  if (!ValidateProto(
-          proto.Pass(), std::string(), std::string(), payload, &policy_data)) {
+  if (!ValidateProto(std::move(proto), std::string(), std::string(), payload,
+                     &policy_data)) {
     return false;
   }
 
   if (!policy_data.has_policy_type())
     return false;
 
   const DomainConstants* constants =
       GetDomainConstantsForType(policy_data.policy_type());
   if (!constants || !policy_data.has_settings_entity_id())
     return false;
 
   ns->domain = constants->domain;
   ns->component_id = policy_data.settings_entity_id();
   return true;
 }
 
 bool ComponentCloudPolicyStore::ValidateProto(
     scoped_ptr<em::PolicyFetchResponse> proto,
     const std::string& policy_type,
     const std::string& settings_entity_id,
     em::ExternalPolicyData* payload,
     em::PolicyData* policy_data) {
   if (username_.empty() || dm_token_.empty())
     return false;
 
   scoped_ptr<ComponentCloudPolicyValidator> validator(
       ComponentCloudPolicyValidator::Create(
-          proto.Pass(), scoped_refptr<base::SequencedTaskRunner>()));
+          std::move(proto), scoped_refptr<base::SequencedTaskRunner>()));
   validator->ValidateUsername(username_, true);
   validator->ValidateDMToken(dm_token_,
                              ComponentCloudPolicyValidator::DM_TOKEN_REQUIRED);
   if (!policy_type.empty())
     validator->ValidatePolicyType(policy_type);
   if (!settings_entity_id.empty())
     validator->ValidateSettingsEntityId(settings_entity_id);
   validator->ValidatePayload();
   // TODO(joaodasilva): validate signature.
   validator->RunValidation();
@@ skipping 62 matching lines @@
     // this must support a configurable scope; assuming POLICY_SCOPE_USER is
     // fine for now.
     policy->Set(it.key(), level, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
                 value.release(), nullptr);
   }
 
   return true;
 }
 
 }  // namespace policy