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

components/policy/core/common/remote_commands/remote_commands_service.cc

 // Copyright 2015 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/remote_commands/remote_commands_service.h"
 
 #include <algorithm>
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "components/policy/core/common/remote_commands/remote_commands_factory.h"
 
 namespace policy {
 
 namespace em = enterprise_management;
 
 RemoteCommandsService::RemoteCommandsService(
     scoped_ptr<RemoteCommandsFactory> factory,
     CloudPolicyClient* client)
-    : factory_(factory.Pass()), client_(client), weak_factory_(this) {
+    : factory_(std::move(factory)), client_(client), weak_factory_(this) {
   DCHECK(client_);
   queue_.AddObserver(this);
 }
 
 RemoteCommandsService::~RemoteCommandsService() {
   queue_.RemoveObserver(this);
 }
 
 bool RemoteCommandsService::FetchRemoteCommands() {
   if (!client_->is_registered())
@@ skipping 20 matching lines @@
     // It's safe to remove these IDs from |fetched_command_ids_| here, since
     // it is guaranteed that there is no earlier fetch request in progress
     // anymore that could have returned these IDs.
     while (!fetched_command_ids_.empty() &&
            fetched_command_ids_.front() != lastest_finished_command_id_) {
       fetched_command_ids_.pop_front();
     }
   }
 
   client_->FetchRemoteCommands(
-      id_to_acknowledge.Pass(), previous_results,
+      std::move(id_to_acknowledge), previous_results,
       base::Bind(&RemoteCommandsService::OnRemoteCommandsFetched,
                  weak_factory_.GetWeakPtr()));
 
   return true;
 }
 
 void RemoteCommandsService::SetClockForTesting(
     scoped_ptr<base::TickClock> clock) {
-  queue_.SetClockForTesting(clock.Pass());
+  queue_.SetClockForTesting(std::move(clock));
 }
 
 void RemoteCommandsService::EnqueueCommand(
     const enterprise_management::RemoteCommand& command) {
   if (!command.has_type() || !command.has_unique_id()) {
     LOG(WARNING) << "Invalid remote command from server.";
     return;
   }
 
   // If the command is already fetched, ignore it.
   if (std::find(fetched_command_ids_.begin(), fetched_command_ids_.end(),
                 command.unique_id()) != fetched_command_ids_.end()) {
     return;
   }
 
   fetched_command_ids_.push_back(command.unique_id());
 
   scoped_ptr<RemoteCommandJob> job = factory_->BuildJobForType(command.type());
 
   if (!job || !job->Init(queue_.GetNowTicks(), command)) {
     em::RemoteCommandResult ignored_result;
     ignored_result.set_result(
         em::RemoteCommandResult_ResultType_RESULT_IGNORED);
     ignored_result.set_unique_id(command.unique_id());
     unsent_results_.push_back(ignored_result);
     return;
   }
 
-  queue_.AddJob(job.Pass());
+  queue_.AddJob(std::move(job));
 }
 
 void RemoteCommandsService::OnJobStarted(RemoteCommandJob* command) {
 }
 
 void RemoteCommandsService::OnJobFinished(RemoteCommandJob* command) {
   has_finished_command_ = true;
   lastest_finished_command_id_ = command->unique_id();
   // TODO(binjin): Attempt to sync |lastest_finished_command_id_| to some
   // persistent source, so that we can reload it later without relying solely on
@@ skipping 38 matching lines @@
       EnqueueCommand(command);
   }
 
   // Start another fetch request job immediately if there are unsent command
   // results or enqueued fetch requests.
   if (!unsent_results_.empty() || has_enqueued_fetch_request_)
     FetchRemoteCommands();
 }
 
 }  // namespace policy