Convert //remoting to use std::unique_ptr

remoting/host/it2me/it2me_host.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/it2me/it2me_host.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "policy/policy_constants.h"
 #include "remoting/base/auto_thread.h"
 #include "remoting/base/chromium_url_request.h"
 #include "remoting/base/logging.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/host/chromoting_host.h"
@@ skipping 19 matching lines @@
 
 namespace {
 
 // This is used for tagging system event logs.
 const char kApplicationName[] = "chromoting";
 const int kMaxLoginAttempts = 5;
 
 }  // namespace
 
 It2MeHost::It2MeHost(
-    scoped_ptr<ChromotingHostContext> host_context,
-    scoped_ptr<PolicyWatcher> policy_watcher,
-    scoped_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory,
+    std::unique_ptr<ChromotingHostContext> host_context,
+    std::unique_ptr<PolicyWatcher> policy_watcher,
+    std::unique_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory,
     base::WeakPtr<It2MeHost::Observer> observer,
     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
     const std::string& directory_bot_jid)
     : host_context_(std::move(host_context)),
       task_runner_(host_context_->ui_task_runner()),
       observer_(observer),
       xmpp_server_config_(xmpp_server_config),
       directory_bot_jid_(directory_bot_jid),
       state_(kDisconnected),
       failed_login_attempts_(0),
@@ skipping 67 matching lines @@
 
   if (policy_received_)
     UpdateNatPolicy(nat_traversal_enabled_);
 }
 
 void It2MeHost::ShowConfirmationPrompt() {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   SetState(kStarting, "");
 
-  scoped_ptr<It2MeConfirmationDialog> confirmation_dialog =
+  std::unique_ptr<It2MeConfirmationDialog> confirmation_dialog =
       confirmation_dialog_factory_->Create();
 
   // TODO(dcaiafa): Remove after dialog implementations for all platforms exist.
   if (!confirmation_dialog) {
     ReadPolicyAndConnect();
     return;
   }
 
   confirmation_dialog_proxy_.reset(
       new It2MeConfirmationDialogProxy(host_context_->ui_task_runner(),
@@ skipping 49 matching lines @@
                       base::CompareCase::INSENSITIVE_ASCII)) {
     SetState(kInvalidDomainError, "");
     return;
   }
 
   // Generate a key pair for the Host to use.
   // TODO(wez): Move this to the worker thread.
   host_key_pair_ = RsaKeyPair::Generate();
 
   // Create XMPP connection.
-  scoped_ptr<SignalStrategy> signal_strategy(
-      new XmppSignalStrategy(net::ClientSocketFactory::GetDefaultFactory(),
-                             host_context_->url_request_context_getter(),
-                             xmpp_server_config_));
+  std::unique_ptr<SignalStrategy> signal_strategy(new XmppSignalStrategy(
+      net::ClientSocketFactory::GetDefaultFactory(),
+      host_context_->url_request_context_getter(), xmpp_server_config_));
 
   // Request registration of the host for support.
-  scoped_ptr<RegisterSupportHostRequest> register_request(
+  std::unique_ptr<RegisterSupportHostRequest> register_request(
       new RegisterSupportHostRequest(
           signal_strategy.get(), host_key_pair_, directory_bot_jid_,
-          base::Bind(&It2MeHost::OnReceivedSupportID,
-                     base::Unretained(this))));
+          base::Bind(&It2MeHost::OnReceivedSupportID, base::Unretained(this))));
 
   // Beyond this point nothing can fail, so save the config and request.
   signal_strategy_ = std::move(signal_strategy);
   register_request_ = std::move(register_request);
 
   // If NAT traversal is off then limit port range to allow firewall pin-holing.
   HOST_LOG << "NAT state: " << nat_traversal_enabled_;
   protocol::NetworkSettings network_settings(
      nat_traversal_enabled_ ?
      protocol::NetworkSettings::NAT_TRAVERSAL_FULL :
      protocol::NetworkSettings::NAT_TRAVERSAL_DISABLED);
   if (!nat_traversal_enabled_) {
     network_settings.port_range.min_port =
         protocol::NetworkSettings::kDefaultMinPort;
     network_settings.port_range.max_port =
         protocol::NetworkSettings::kDefaultMaxPort;
   }
 
   scoped_refptr<protocol::TransportContext> transport_context =
       new protocol::TransportContext(
           signal_strategy_.get(),
-          make_scoped_ptr(new protocol::ChromiumPortAllocatorFactory()),
-          make_scoped_ptr(new ChromiumUrlRequestFactory(
+          base::WrapUnique(new protocol::ChromiumPortAllocatorFactory()),
+          base::WrapUnique(new ChromiumUrlRequestFactory(
               host_context_->url_request_context_getter())),
           network_settings, protocol::TransportRole::SERVER);
   transport_context->set_ice_config_url(
       ServiceUrls::GetInstance()->ice_config_url());
 
-  scoped_ptr<protocol::SessionManager> session_manager(
+  std::unique_ptr<protocol::SessionManager> session_manager(
       new protocol::JingleSessionManager(signal_strategy_.get()));
 
-  scoped_ptr<protocol::CandidateSessionConfig> protocol_config =
+  std::unique_ptr<protocol::CandidateSessionConfig> protocol_config =
       protocol::CandidateSessionConfig::CreateDefault();
   // Disable audio by default.
   // TODO(sergeyu): Add UI to enable it.
   protocol_config->DisableAudioChannel();
   session_manager->set_protocol_config(std::move(protocol_config));
 
   // Create the host.
   host_.reset(new ChromotingHost(desktop_environment_factory_.get(),
                                  std::move(session_manager), transport_context,
                                  host_context_->audio_task_runner(),
@@ skipping 45 matching lines @@
 
   SetState(kConnected, "");
 }
 
 void It2MeHost::OnClientDisconnected(const std::string& jid) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   Shutdown();
 }
 
-void It2MeHost::OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
+void It2MeHost::OnPolicyUpdate(
+    std::unique_ptr<base::DictionaryValue> policies) {
   // The policy watcher runs on the |ui_task_runner|.
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
     host_context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&It2MeHost::OnPolicyUpdate, this, base::Passed(&policies)));
     return;
   }
 
   bool nat_policy;
   if (policies->GetBoolean(policy::key::kRemoteAccessHostFirewallTraversal,
@@ skipping 142 matching lines @@
 
   std::string local_certificate = host_key_pair_->GenerateCertificate();
   if (local_certificate.empty()) {
     std::string error_message = "Failed to generate host certificate.";
     LOG(ERROR) << error_message;
     SetState(kError, error_message);
     Shutdown();
     return;
   }
 
-  scoped_ptr<protocol::AuthenticatorFactory> factory(
+  std::unique_ptr<protocol::AuthenticatorFactory> factory(
       new protocol::It2MeHostAuthenticatorFactory(
           local_certificate, host_key_pair_, access_code_hash,
           required_client_domain_));
   host_->SetAuthenticatorFactory(std::move(factory));
 
   // Pass the Access Code to the script object before changing state.
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::Observer::OnStoreAccessCode,
                             observer_, access_code, lifetime));
 
   SetState(kReceivedAccessCode, "");
 }
 
 It2MeHostFactory::It2MeHostFactory() : policy_service_(nullptr) {
 }
 
 It2MeHostFactory::~It2MeHostFactory() {}
 
 void It2MeHostFactory::set_policy_service(
     policy::PolicyService* policy_service) {
   DCHECK(policy_service);
   DCHECK(!policy_service_) << "|policy_service| can only be set once.";
   policy_service_ = policy_service;
 }
 
 scoped_refptr<It2MeHost> It2MeHostFactory::CreateIt2MeHost(
-    scoped_ptr<ChromotingHostContext> context,
+    std::unique_ptr<ChromotingHostContext> context,
     base::WeakPtr<It2MeHost::Observer> observer,
     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
     const std::string& directory_bot_jid) {
   DCHECK(context->ui_task_runner()->BelongsToCurrentThread());
 
-  scoped_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory(
+  std::unique_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory(
       new It2MeConfirmationDialogFactory());
-  scoped_ptr<PolicyWatcher> policy_watcher =
+  std::unique_ptr<PolicyWatcher> policy_watcher =
       PolicyWatcher::Create(policy_service_, context->file_task_runner());
   return new It2MeHost(std::move(context), std::move(policy_watcher),
                        std::move(confirmation_dialog_factory), observer,
                        xmpp_server_config, directory_bot_jid);
 }
 
 }  // namespace remoting