Convert //remoting to use std::unique_ptr

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)
+DaemonController::DaemonController(std::unique_ptr<Delegate> delegate)
     : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       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_ =
@@ skipping 10 matching lines @@
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   DaemonController::GetConfigCallback wrapped_done = base::Bind(
       &DaemonController::InvokeConfigCallbackAndScheduleNext, this, done);
   base::Closure request = base::Bind(
       &DaemonController::DoGetConfig, this, wrapped_done);
   ServiceOrQueueRequest(request);
 }
 
 void DaemonController::SetConfigAndStart(
-    scoped_ptr<base::DictionaryValue> config,
+    std::unique_ptr<base::DictionaryValue> config,
     bool consent,
     const CompletionCallback& done) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   DaemonController::CompletionCallback wrapped_done = base::Bind(
       &DaemonController::InvokeCompletionCallbackAndScheduleNext, this, done);
   base::Closure request = base::Bind(
       &DaemonController::DoSetConfigAndStart, this, base::Passed(&config),
       consent, wrapped_done);
   ServiceOrQueueRequest(request);
 }
 
-void DaemonController::UpdateConfig(scoped_ptr<base::DictionaryValue> config,
-                                    const CompletionCallback& done) {
+void DaemonController::UpdateConfig(
+    std::unique_ptr<base::DictionaryValue> config,
+    const CompletionCallback& done) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   DaemonController::CompletionCallback wrapped_done = base::Bind(
       &DaemonController::InvokeCompletionCallbackAndScheduleNext, this, done);
   base::Closure request = base::Bind(
       &DaemonController::DoUpdateConfig, this, base::Passed(&config),
       wrapped_done);
   ServiceOrQueueRequest(request);
 }
 
@@ skipping 23 matching lines @@
   delegate_task_runner_->DeleteSoon(FROM_HERE, delegate_.release());
 
   // Stop the thread.
   delegate_task_runner_ = nullptr;
   caller_task_runner_->DeleteSoon(FROM_HERE, delegate_thread_.release());
 }
 
 void DaemonController::DoGetConfig(const GetConfigCallback& done) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
-  scoped_ptr<base::DictionaryValue> config = delegate_->GetConfig();
+  std::unique_ptr<base::DictionaryValue> config = delegate_->GetConfig();
   caller_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(done, base::Passed(&config)));
 }
 
 void DaemonController::DoSetConfigAndStart(
-    scoped_ptr<base::DictionaryValue> config,
+    std::unique_ptr<base::DictionaryValue> config,
     bool consent,
     const CompletionCallback& done) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   delegate_->SetConfigAndStart(std::move(config), consent, done);
 }
 
 void DaemonController::DoUpdateConfig(
-    scoped_ptr<base::DictionaryValue> config,
+    std::unique_ptr<base::DictionaryValue> config,
     const CompletionCallback& done) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   delegate_->UpdateConfig(std::move(config), done);
 }
 
 void DaemonController::DoStop(const CompletionCallback& done) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   delegate_->Stop(done);
@@ skipping 18 matching lines @@
                    this, done, result));
     return;
   }
 
   done.Run(result);
   ScheduleNext();
 }
 
 void DaemonController::InvokeConfigCallbackAndScheduleNext(
     const GetConfigCallback& done,
-    scoped_ptr<base::DictionaryValue> config) {
+    std::unique_ptr<base::DictionaryValue> config) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   done.Run(std::move(config));
   ScheduleNext();
 }
 
 void DaemonController::InvokeConsentCallbackAndScheduleNext(
     const GetUsageStatsConsentCallback& done,
     const UsageStatsConsent& consent) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
@@ skipping 15 matching lines @@
   if (!servicing_request)
     ServiceNextRequest();
 }
 
 void DaemonController::ServiceNextRequest() {
   if (!pending_requests_.empty())
     delegate_task_runner_->PostTask(FROM_HERE, pending_requests_.front());
 }
 
 }  // namespace remoting