Convert //remoting to use std::unique_ptr

remoting/host/setup/host_starter.cc

 // Copyright (c) 2012 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/host_starter.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/guid.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "google_apis/google_api_keys.h"
 #include "remoting/host/pin_hash.h"
 #include "remoting/host/setup/oauth_helper.h"
 
 namespace {
 const int kMaxGetTokensRetries = 3;
 }  // namespace
 
 namespace remoting {
 
 HostStarter::HostStarter(
-    scoped_ptr<gaia::GaiaOAuthClient> oauth_client,
-    scoped_ptr<remoting::ServiceClient> service_client,
+    std::unique_ptr<gaia::GaiaOAuthClient> oauth_client,
+    std::unique_ptr<remoting::ServiceClient> service_client,
     scoped_refptr<remoting::DaemonController> daemon_controller)
     : oauth_client_(std::move(oauth_client)),
       service_client_(std::move(service_client)),
       daemon_controller_(daemon_controller),
       consent_to_data_collection_(false),
       unregistering_host_(false),
       weak_ptr_factory_(this) {
   weak_ptr_ = weak_ptr_factory_.GetWeakPtr();
   main_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 HostStarter::~HostStarter() {}
 
-scoped_ptr<HostStarter> HostStarter::Create(
+std::unique_ptr<HostStarter> HostStarter::Create(
     const std::string& chromoting_hosts_url,
     net::URLRequestContextGetter* url_request_context_getter) {
-  return make_scoped_ptr(new HostStarter(
-      make_scoped_ptr(new gaia::GaiaOAuthClient(url_request_context_getter)),
-      make_scoped_ptr(new remoting::ServiceClient(chromoting_hosts_url,
-                                                  url_request_context_getter)),
+  return base::WrapUnique(new HostStarter(
+      base::WrapUnique(new gaia::GaiaOAuthClient(url_request_context_getter)),
+      base::WrapUnique(new remoting::ServiceClient(chromoting_hosts_url,
+                                                   url_request_context_getter)),
       remoting::DaemonController::Create()));
 }
 
 void HostStarter::StartHost(
     const std::string& host_name,
     const std::string& host_pin,
     bool consent_to_data_collection,
     const std::string& auth_code,
     const std::string& redirect_url,
     CompletionCallback on_done) {
@@ skipping 91 matching lines @@
       google_apis::GetOAuth2ClientSecret(
           google_apis::CLIENT_REMOTING_HOST);
   oauth_client_info_.redirect_uri = "oob";
   oauth_client_->GetTokensFromAuthCode(
       oauth_client_info_, authorization_code, kMaxGetTokensRetries, this);
 }
 
 void HostStarter::StartHostProcess() {
   // Start the host.
   std::string host_secret_hash = remoting::MakeHostPinHash(host_id_, host_pin_);
-  scoped_ptr<base::DictionaryValue> config(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> config(new base::DictionaryValue());
   if (host_owner_ != xmpp_login_) {
     config->SetString("host_owner", host_owner_);
   }
   config->SetString("xmpp_login", xmpp_login_);
   config->SetString("oauth_refresh_token", refresh_token_);
   config->SetString("host_id", host_id_);
   config->SetString("host_name", host_name_);
   config->SetString("private_key", key_pair_->ToString());
   config->SetString("host_secret_hash", host_secret_hash);
   daemon_controller_->SetConfigAndStart(
@@ skipping 46 matching lines @@
 void HostStarter::OnHostUnregistered() {
   if (!main_task_runner_->BelongsToCurrentThread()) {
     main_task_runner_->PostTask(FROM_HERE, base::Bind(
         &HostStarter::OnHostUnregistered, weak_ptr_));
     return;
   }
   base::ResetAndReturn(&on_done_).Run(START_ERROR);
 }
 
 }  // namespace remoting