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

components/update_client/update_client.cc

 // Copyright 2014 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/update_client/update_client.h"
 
 #include <algorithm>
 #include <queue>
 #include <set>
 #include <utility>
@@ skipping 52 matching lines @@
 // Using unretained references is allowed in this case since the life time of
 // the UpdateClient instance exceeds the life time of its inner members,
 // including any thread objects that might execute callbacks bound to it.
 UpdateClientImpl::UpdateClientImpl(
     const scoped_refptr<Configurator>& config,
     scoped_ptr<PingManager> ping_manager,
     UpdateChecker::Factory update_checker_factory,
     CrxDownloader::Factory crx_downloader_factory)
     : is_stopped_(false),
       config_(config),
-      ping_manager_(ping_manager.Pass()),
+      ping_manager_(std::move(ping_manager)),
       update_engine_(
           new UpdateEngine(config,
                            update_checker_factory,
                            crx_downloader_factory,
                            ping_manager_.get(),
                            base::Bind(&UpdateClientImpl::NotifyObservers,
                                       base::Unretained(this)))) {}
 
 UpdateClientImpl::~UpdateClientImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 18 matching lines @@
   ids.push_back(id);
 
   // Partially applies |completion_callback| to OnTaskComplete, so this
   // argument is available when the task completes, along with the task itself.
   const auto callback =
       base::Bind(&UpdateClientImpl::OnTaskComplete, this, completion_callback);
   scoped_ptr<TaskUpdate> task(new TaskUpdate(update_engine_.get(), true, ids,
                                              crx_data_callback, callback));
 
   // Install tasks are run concurrently and never queued up.
-  RunTask(task.Pass());
+  RunTask(std::move(task));
 }
 
 void UpdateClientImpl::Update(const std::vector<std::string>& ids,
                               const CrxDataCallback& crx_data_callback,
                               const CompletionCallback& completion_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const auto callback =
       base::Bind(&UpdateClientImpl::OnTaskComplete, this, completion_callback);
   scoped_ptr<TaskUpdate> task(new TaskUpdate(update_engine_.get(), false, ids,
                                              crx_data_callback, callback));
 
   // If no other tasks are running at the moment, run this update task.
   // Otherwise, queue the task up.
   if (tasks_.empty()) {
-    RunTask(task.Pass());
+    RunTask(std::move(task));
   } else {
     task_queue_.push(task.release());
   }
 }
 
 void UpdateClientImpl::RunTask(scoped_ptr<Task> task) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&Task::Run, base::Unretained(task.get())));
   tasks_.insert(task.release());
@@ skipping 16 matching lines @@
   // Delete the completed task. A task can be completed because the update
   // engine has run it or because it has been canceled but never run.
   delete task;
 
   if (is_stopped_)
     return;
 
   // Pick up a task from the queue if the queue has pending tasks and no other
   // task is running.
   if (tasks_.empty() && !task_queue_.empty()) {
-    RunTask(scoped_ptr<Task>(task_queue_.front()).Pass());
+    RunTask(scoped_ptr<Task>(task_queue_.front()));
     task_queue_.pop();
   }
 }
 
 void UpdateClientImpl::AddObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observer_list_.AddObserver(observer);
 }
 
 void UpdateClientImpl::RemoveObserver(Observer* observer) {
@@ skipping 46 matching lines @@
   while (!task_queue_.empty()) {
     const auto task(task_queue_.front());
     task_queue_.pop();
     task->Cancel();
   }
 }
 
 scoped_refptr<UpdateClient> UpdateClientFactory(
     const scoped_refptr<Configurator>& config) {
   scoped_ptr<PingManager> ping_manager(new PingManager(*config));
-  return new UpdateClientImpl(config, ping_manager.Pass(),
+  return new UpdateClientImpl(config, std::move(ping_manager),
                               &UpdateChecker::Create, &CrxDownloader::Create);
 }
 
 }  // namespace update_client