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

components/policy/core/common/cloud/external_policy_data_fetcher.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/external_policy_data_fetcher.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
@@ skipping 116 matching lines @@
                                               Result result,
                                               scoped_ptr<std::string> data) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   JobSet::iterator it = jobs_.find(job);
   if (it == jobs_.end()) {
     // The |job| has been canceled and removed from |jobs_| already. This can
     // happen because the |backend_| runs on a different thread and a |job| may
     // finish before the cancellation has reached that thread.
     return;
   }
-  callback.Run(result, data.Pass());
+  callback.Run(result, std::move(data));
   jobs_.erase(it);
   delete job;
 }
 
 ExternalPolicyDataFetcherBackend::ExternalPolicyDataFetcherBackend(
     scoped_refptr<base::SequencedTaskRunner> io_task_runner,
     scoped_refptr<net::URLRequestContextGetter> request_context)
     : io_task_runner_(io_task_runner),
       request_context_(request_context),
       last_fetch_id_(-1),
@@ skipping 80 matching lines @@
     if (static_cast<int64_t>(data->size()) > it->second->max_size) {
       // Received |data| exceeds maximum allowed size.
       data.reset();
       result = ExternalPolicyDataFetcher::MAX_SIZE_EXCEEDED;
     }
   }
 
   ExternalPolicyDataFetcher::Job* job = it->second;
   delete it->first;
   job_map_.erase(it);
-  job->callback.Run(job, result, data.Pass());
+  job->callback.Run(job, result, std::move(data));
 }
 
 void ExternalPolicyDataFetcherBackend::OnURLFetchDownloadProgress(
     const net::URLFetcher* source,
     int64_t current,
     int64_t total) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   JobMap::iterator it = job_map_.find(const_cast<net::URLFetcher*>(source));
   DCHECK(it != job_map_.end());
   if (it == job_map_.end())
     return;
 
   // Reject the data if it exceeds the size limit. The content length is in
   // |total|, and it may be -1 when not known.
   if (current > it->second->max_size || total > it->second->max_size) {
     ExternalPolicyDataFetcher::Job* job = it->second;
     delete it->first;
     job_map_.erase(it);
     job->callback.Run(job,
                       ExternalPolicyDataFetcher::MAX_SIZE_EXCEEDED,
                       scoped_ptr<std::string>());
   }
 }
 
 }  // namespace policy