Use std::move() instead of .Pass() in remoting/host

remoting/host/setup/daemon_controller.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 "remoting/host/setup/daemon_controller.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "remoting/base/auto_thread.h"
 #include "remoting/base/auto_thread_task_runner.h"
 
 namespace remoting {
 
 // Name of the Daemon Controller's worker thread.
 const char kDaemonControllerThreadName[] = "Daemon Controller thread";
 
 DaemonController::DaemonController(scoped_ptr<Delegate> delegate)
     : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      delegate_(delegate.Pass()) {
+      delegate_(std::move(delegate)) {
   // Launch the delegate thread.
   delegate_thread_.reset(new AutoThread(kDaemonControllerThreadName));
 #if defined(OS_WIN)
   delegate_thread_->SetComInitType(AutoThread::COM_INIT_STA);
   delegate_task_runner_ =
       delegate_thread_->StartWithType(base::MessageLoop::TYPE_UI);
 #else
   delegate_task_runner_ =
       delegate_thread_->StartWithType(base::MessageLoop::TYPE_DEFAULT);
 #endif
@@ skipping 77 matching lines @@
   caller_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(done, base::Passed(&config)));
 }
 
 void DaemonController::DoSetConfigAndStart(
     scoped_ptr<base::DictionaryValue> config,
     bool consent,
     const CompletionCallback& done) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
-  delegate_->SetConfigAndStart(config.Pass(), consent, done);
+  delegate_->SetConfigAndStart(std::move(config), consent, done);
 }
 
 void DaemonController::DoUpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
     const CompletionCallback& done) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
-  delegate_->UpdateConfig(config.Pass(), done);
+  delegate_->UpdateConfig(std::move(config), done);
 }
 
 void DaemonController::DoStop(const CompletionCallback& done) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   delegate_->Stop(done);
 }
 
 void DaemonController::DoGetUsageStatsConsent(
     const GetUsageStatsConsentCallback& done) {
@@ skipping 17 matching lines @@
 
   done.Run(result);
   ScheduleNext();
 }
 
 void DaemonController::InvokeConfigCallbackAndScheduleNext(
     const GetConfigCallback& done,
     scoped_ptr<base::DictionaryValue> config) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  done.Run(config.Pass());
+  done.Run(std::move(config));
   ScheduleNext();
 }
 
 void DaemonController::InvokeConsentCallbackAndScheduleNext(
     const GetUsageStatsConsentCallback& done,
     const UsageStatsConsent& consent) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   done.Run(consent);
   ScheduleNext();
@@ skipping 12 matching lines @@
   if (!servicing_request)
     ServiceNextRequest();
 }
 
 void DaemonController::ServiceNextRequest() {
   if (!pending_requests_.empty())
     delegate_task_runner_->PostTask(FROM_HERE, pending_requests_.front());
 }
 
 }  // namespace remoting