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

components/policy/core/common/cloud/cloud_policy_validator.h

 // 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.
 
 #ifndef COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_VALIDATOR_H_
 #define COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_VALIDATOR_H_
 
 #include <stdint.h>
-
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ skipping 295 matching lines @@
 
   virtual ~CloudPolicyValidator() {}
 
   // Creates a new validator.
   // |background_task_runner| is optional; if RunValidation() is used directly
   // and StartValidation() is not used then it can be NULL.
   static CloudPolicyValidator<PayloadProto>* Create(
       scoped_ptr<enterprise_management::PolicyFetchResponse> policy_response,
       scoped_refptr<base::SequencedTaskRunner> background_task_runner) {
     return new CloudPolicyValidator(
-        policy_response.Pass(),
-        scoped_ptr<PayloadProto>(new PayloadProto()),
-        background_task_runner);
+        std::move(policy_response),
+        scoped_ptr<PayloadProto>(new PayloadProto()), background_task_runner);
   }
 
   scoped_ptr<PayloadProto>& payload() {
     return payload_;
   }
 
   // Kicks off asynchronous validation. |completion_callback| is invoked when
   // done. From this point on, the validator manages its own lifetime - this
   // allows callers to provide a WeakPtr in the callback without leaking the
   // validator.
   void StartValidation(const CompletionCallback& completion_callback) {
     PostValidationTask(base::Bind(completion_callback, this));
   }
 
  private:
   CloudPolicyValidator(
       scoped_ptr<enterprise_management::PolicyFetchResponse> policy_response,
       scoped_ptr<PayloadProto> payload,
       scoped_refptr<base::SequencedTaskRunner> background_task_runner)
-      : CloudPolicyValidatorBase(policy_response.Pass(),
+      : CloudPolicyValidatorBase(std::move(policy_response),
                                  payload.get(),
                                  background_task_runner),
-        payload_(payload.Pass()) {}
+        payload_(std::move(payload)) {}
 
   scoped_ptr<PayloadProto> payload_;
 
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyValidator);
 };
 
 typedef CloudPolicyValidator<enterprise_management::CloudPolicySettings>
     UserCloudPolicyValidator;
 
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 typedef CloudPolicyValidator<enterprise_management::ExternalPolicyData>
     ComponentCloudPolicyValidator;
 #endif
 
 }  // namespace policy
 
 #endif  // COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_VALIDATOR_H_