Convert //remoting to use std::unique_ptr

remoting/host/remoting_me2me_host.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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "ipc/attachment_broker_unprivileged.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
@@ skipping 164 matching lines @@
   bool started() const override { return done_; }
   RejectionReason rejection_reason() const override {
     NOTREACHED();
     return INVALID_CREDENTIALS;
   }
   void ProcessMessage(const buzz::XmlElement* message,
                       const base::Closure& resume_callback) override {
     done_ = true;
     resume_callback.Run();
   }
-  scoped_ptr<buzz::XmlElement> GetNextMessage() override {
+  std::unique_ptr<buzz::XmlElement> GetNextMessage() override {
     NOTREACHED();
     return nullptr;
   }
   const std::string& GetAuthKey() const override { return auth_key_; }
-  scoped_ptr<protocol::ChannelAuthenticator> CreateChannelAuthenticator()
+  std::unique_ptr<protocol::ChannelAuthenticator> CreateChannelAuthenticator()
       const override {
     NOTREACHED();
     return nullptr;
   };
 
  private:
   bool done_ = false;
   std::string auth_key_ = "NOKEY";
 };
 
 // Factory for Authenticator instances.
 class NoopAuthenticatorFactory : public protocol::AuthenticatorFactory {
  public:
   NoopAuthenticatorFactory() {}
   ~NoopAuthenticatorFactory() override {}
 
-  scoped_ptr<protocol::Authenticator> CreateAuthenticator(
+  std::unique_ptr<protocol::Authenticator> CreateAuthenticator(
       const std::string& local_jid,
       const std::string& remote_jid) override {
-    return make_scoped_ptr(new NoopAuthenticator());
+    return base::WrapUnique(new NoopAuthenticator());
   }
 };
 
 #endif  // !defined(NDEBUG)
 
 class HostProcess : public ConfigWatcher::Delegate,
                     public HostChangeNotificationListener::Listener,
                     public IPC::Listener,
                     public base::RefCountedThreadSafe<HostProcess> {
  public:
   // |shutdown_watchdog| is armed when shutdown is started, and should be kept
   // alive as long as possible until the process exits (since destroying the
   // watchdog disarms it).
-  HostProcess(scoped_ptr<ChromotingHostContext> context,
+  HostProcess(std::unique_ptr<ChromotingHostContext> context,
               int* exit_code_out,
               ShutdownWatchdog* shutdown_watchdog);
 
   // ConfigWatcher::Delegate interface.
   void OnConfigUpdated(const std::string& serialized_config) override;
   void OnConfigWatcherError() override;
 
   // IPC::Listener implementation.
   bool OnMessageReceived(const IPC::Message& message) override;
   void OnChannelError() override;
@@ skipping 68 matching lines @@
   // Called on the network thread to set the host's Authenticator factory.
   void CreateAuthenticatorFactory();
 
   // Tear down resources that run on the UI thread.
   void ShutdownOnUiThread();
 
   // Applies the host config, returning true if successful.
   bool ApplyConfig(const base::DictionaryValue& config);
 
   // Handles policy updates, by calling On*PolicyUpdate methods.
-  void OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies);
+  void OnPolicyUpdate(std::unique_ptr<base::DictionaryValue> policies);
   void OnPolicyError();
   void ReportPolicyErrorAndRestartHost();
   void ApplyHostDomainPolicy();
   void ApplyUsernamePolicy();
   bool OnClientDomainPolicyUpdate(base::DictionaryValue* policies);
   bool OnHostDomainPolicyUpdate(base::DictionaryValue* policies);
   bool OnUsernamePolicyUpdate(base::DictionaryValue* policies);
   bool OnNatPolicyUpdate(base::DictionaryValue* policies);
   bool OnRelayPolicyUpdate(base::DictionaryValue* policies);
   bool OnUdpPortPolicyUpdate(base::DictionaryValue* policies);
@@ skipping 30 matching lines @@
       IPC::PlatformFileForTransit unprivileged_key);
 #endif  // defined(OS_WIN)
 
   // Crashes the process in response to a daemon's request. The daemon passes
   // the location of the code that detected the fatal error resulted in this
   // request.
   void OnCrash(const std::string& function_name,
                const std::string& file_name,
                const int& line_number);
 
-  scoped_ptr<ChromotingHostContext> context_;
+  std::unique_ptr<ChromotingHostContext> context_;
 
   // XMPP server/remoting bot configuration (initialized from the command line).
   XmppSignalStrategy::XmppServerConfig xmpp_server_config_;
   std::string directory_bot_jid_;
 
   // Created on the UI thread but used from the network thread.
   base::FilePath host_config_path_;
   std::string host_config_;
-  scoped_ptr<DesktopEnvironmentFactory> desktop_environment_factory_;
+  std::unique_ptr<DesktopEnvironmentFactory> desktop_environment_factory_;
 
   // Accessed on the network thread.
   HostState state_ = HOST_STARTING;
 
-  scoped_ptr<ConfigWatcher> config_watcher_;
+  std::unique_ptr<ConfigWatcher> config_watcher_;
 
   std::string host_id_;
   std::string pin_hash_;
   scoped_refptr<RsaKeyPair> key_pair_;
   std::string oauth_refresh_token_;
   std::string serialized_config_;
   std::string host_owner_;
   std::string host_owner_email_;
   bool use_service_account_ = false;
   bool enable_vp9_ = false;
 
-  scoped_ptr<PolicyWatcher> policy_watcher_;
+  std::unique_ptr<PolicyWatcher> policy_watcher_;
   PolicyState policy_state_ = POLICY_INITIALIZING;
   std::string client_domain_;
   std::string host_domain_;
   bool host_username_match_required_ = false;
   bool allow_nat_traversal_ = true;
   bool allow_relay_ = true;
   PortRange udp_port_range_;
   std::string talkgadget_prefix_;
   bool allow_pairing_ = true;
 
   bool curtain_required_ = false;
   ThirdPartyAuthConfig third_party_auth_config_;
   bool gnubby_auth_policy_enabled_ = false;
   bool gnubby_extension_supported_ = false;
 
   // Boolean to change flow, where necessary, if we're
   // capturing a window instead of the entire desktop.
   bool enable_window_capture_ = false;
 
   // Used to specify which window to stream, if enabled.
   webrtc::WindowId window_id_ = 0;
 
   // Must outlive |gcd_state_updater_| and |signaling_connector_|.
-  scoped_ptr<OAuthTokenGetter> oauth_token_getter_;
+  std::unique_ptr<OAuthTokenGetter> oauth_token_getter_;
 
   // Must outlive |signaling_connector_|, |gcd_subscriber_|, and
   // |heartbeat_sender_|.
-  scoped_ptr<SignalStrategy> signal_strategy_;
+  std::unique_ptr<SignalStrategy> signal_strategy_;
 
-  scoped_ptr<SignalingConnector> signaling_connector_;
-  scoped_ptr<HeartbeatSender> heartbeat_sender_;
+  std::unique_ptr<SignalingConnector> signaling_connector_;
+  std::unique_ptr<HeartbeatSender> heartbeat_sender_;
 #if defined(USE_GCD)
-  scoped_ptr<GcdStateUpdater> gcd_state_updater_;
-  scoped_ptr<PushNotificationSubscriber> gcd_subscriber_;
+  std::unique_ptr<GcdStateUpdater> gcd_state_updater_;
+  std::unique_ptr<PushNotificationSubscriber> gcd_subscriber_;
 #endif  // defined(USE_GCD)
 
-  scoped_ptr<HostChangeNotificationListener> host_change_notification_listener_;
-  scoped_ptr<HostStatusLogger> host_status_logger_;
-  scoped_ptr<HostEventLogger> host_event_logger_;
+  std::unique_ptr<HostChangeNotificationListener>
+      host_change_notification_listener_;
+  std::unique_ptr<HostStatusLogger> host_status_logger_;
+  std::unique_ptr<HostEventLogger> host_event_logger_;
 
-  scoped_ptr<ChromotingHost> host_;
+  std::unique_ptr<ChromotingHost> host_;
 
   // Used to keep this HostProcess alive until it is shutdown.
   scoped_refptr<HostProcess> self_;
 
 #if defined(REMOTING_MULTI_PROCESS)
   // Accessed on the UI thread.
-  scoped_ptr<IPC::ChannelProxy> daemon_channel_;
+  std::unique_ptr<IPC::ChannelProxy> daemon_channel_;
 
   // Owned as |desktop_environment_factory_|.
   DesktopSessionConnector* desktop_session_connector_ = nullptr;
 #endif  // defined(REMOTING_MULTI_PROCESS)
 
   int* exit_code_out_;
   bool signal_parent_ = false;
 
   scoped_refptr<PairingRegistry> pairing_registry_;
 
   ShutdownWatchdog* shutdown_watchdog_;
 
   DISALLOW_COPY_AND_ASSIGN(HostProcess);
 };
 
-HostProcess::HostProcess(scoped_ptr<ChromotingHostContext> context,
+HostProcess::HostProcess(std::unique_ptr<ChromotingHostContext> context,
                          int* exit_code_out,
                          ShutdownWatchdog* shutdown_watchdog)
     : context_(std::move(context)),
       self_(this),
       exit_code_out_(exit_code_out),
       shutdown_watchdog_(shutdown_watchdog) {
   StartOnUiThread();
 }
 
 HostProcess::~HostProcess() {
@@ skipping 44 matching lines @@
   if (broker && !broker->IsPrivilegedBroker())
     broker->RegisterBrokerCommunicationChannel(daemon_channel_.get());
 
 #else  // !defined(REMOTING_MULTI_PROCESS)
   if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
     host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
 
     // Read config from stdin if necessary.
     if (host_config_path_ == base::FilePath(kStdinConfigPath)) {
       const size_t kBufferSize = 4096;
-      scoped_ptr<char[]> buf(new char[kBufferSize]);
+      std::unique_ptr<char[]> buf(new char[kBufferSize]);
       size_t len;
       while ((len = fread(buf.get(), 1, kBufferSize, stdin)) > 0) {
         host_config_.append(buf.get(), len);
       }
     }
   } else {
     base::FilePath default_config_dir = remoting::GetConfigDir();
     host_config_path_ = default_config_dir.Append(kDefaultHostConfigFile);
   }
 
@@ skipping 54 matching lines @@
     return;
   }
 
   // Filter out duplicates.
   if (serialized_config_ == serialized_config)
     return;
 
   HOST_LOG << "Processing new host configuration.";
 
   serialized_config_ = serialized_config;
-  scoped_ptr<base::DictionaryValue> config(
+  std::unique_ptr<base::DictionaryValue> config(
       HostConfigFromJson(serialized_config));
   if (!config) {
     LOG(ERROR) << "Invalid configuration.";
     ShutdownHost(kInvalidHostConfigurationExitCode);
     return;
   }
 
   if (!ApplyConfig(*config)) {
     LOG(ERROR) << "Failed to apply the configuration.";
     ShutdownHost(kInvalidHostConfigurationExitCode);
@@ skipping 108 matching lines @@
   if (state_ != HOST_STARTED)
     return;
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           kDisableAuthenticationSwitchName)) {
 #if defined(NDEBUG)
     LOG(ERROR) << "Authentication can be disabled only in debug builds.";
     ShutdownHost(kInitializationFailed);
 #else  // defined(NDEBUG)
     host_->SetAuthenticatorFactory(
-        make_scoped_ptr(new NoopAuthenticatorFactory()));
+        base::WrapUnique(new NoopAuthenticatorFactory()));
 #endif  // !defined(NDEBUG)
     return;
   }
 
   std::string local_certificate = key_pair_->GenerateCertificate();
   if (local_certificate.empty()) {
     LOG(ERROR) << "Failed to generate host certificate.";
     ShutdownHost(kInitializationFailed);
     return;
   }
 
-  scoped_ptr<protocol::AuthenticatorFactory> factory;
+  std::unique_ptr<protocol::AuthenticatorFactory> factory;
 
   if (third_party_auth_config_.is_null()) {
     scoped_refptr<PairingRegistry> pairing_registry;
     if (allow_pairing_) {
       // On Windows |pairing_registry_| is initialized in
       // InitializePairingRegistry().
 #if !defined(OS_WIN)
       if (!pairing_registry_) {
-        scoped_ptr<PairingRegistry::Delegate> delegate =
+        std::unique_ptr<PairingRegistry::Delegate> delegate =
             CreatePairingRegistryDelegate();
 
         if (delegate)
           pairing_registry_ = new PairingRegistry(context_->file_task_runner(),
                                                   std::move(delegate));
       }
 #endif  // defined(OS_WIN)
 
       pairing_registry = pairing_registry_;
     }
@@ skipping 194 matching lines @@
   // |privileged_key| can be nullptr but not |unprivileged_key|.
   DCHECK(unprivileged_key.IsValid());
   // |pairing_registry_| should only be initialized once.
   DCHECK(!pairing_registry_);
 
   HKEY privileged_hkey = reinterpret_cast<HKEY>(
       IPC::PlatformFileForTransitToPlatformFile(privileged_key));
   HKEY unprivileged_hkey = reinterpret_cast<HKEY>(
       IPC::PlatformFileForTransitToPlatformFile(unprivileged_key));
 
-  scoped_ptr<PairingRegistryDelegateWin> delegate(
+  std::unique_ptr<PairingRegistryDelegateWin> delegate(
       new PairingRegistryDelegateWin());
   delegate->SetRootKeys(privileged_hkey, unprivileged_hkey);
 
   pairing_registry_ = new PairingRegistry(context_->file_task_runner(),
                                           std::move(delegate));
 
   // (Re)Create the authenticator factory now that |pairing_registry_| has been
   // initialized.
   CreateAuthenticatorFactory();
 }
@@ skipping 53 matching lines @@
   // Allow offering of VP9 encoding to be overridden by the command-line.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kEnableVp9SwitchName)) {
     enable_vp9_ = true;
   } else {
     config.GetBoolean(kEnableVp9ConfigPath, &enable_vp9_);
   }
 
   return true;
 }
 
-void HostProcess::OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
+void HostProcess::OnPolicyUpdate(
+    std::unique_ptr<base::DictionaryValue> policies) {
   if (!context_->network_task_runner()->BelongsToCurrentThread()) {
     context_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&HostProcess::OnPolicyUpdate, this,
                               base::Passed(&policies)));
     return;
   }
 
   bool restart_required = false;
   restart_required |= OnClientDomainPolicyUpdate(policies.get());
   restart_required |= OnHostDomainPolicyUpdate(policies.get());
@@ skipping 320 matching lines @@
 #endif  // defined(USE_GCD)
   DCHECK(!heartbeat_sender_);
 
   // Create SignalStrategy.
   XmppSignalStrategy* xmpp_signal_strategy = new XmppSignalStrategy(
       net::ClientSocketFactory::GetDefaultFactory(),
       context_->url_request_context_getter(), xmpp_server_config_);
   signal_strategy_.reset(xmpp_signal_strategy);
 
   // Create SignalingConnector.
-  scoped_ptr<DnsBlackholeChecker> dns_blackhole_checker(new DnsBlackholeChecker(
-      context_->url_request_context_getter(), talkgadget_prefix_));
-  scoped_ptr<OAuthTokenGetter::OAuthCredentials> oauth_credentials(
+  std::unique_ptr<DnsBlackholeChecker> dns_blackhole_checker(
+      new DnsBlackholeChecker(context_->url_request_context_getter(),
+                              talkgadget_prefix_));
+  std::unique_ptr<OAuthTokenGetter::OAuthCredentials> oauth_credentials(
       new OAuthTokenGetter::OAuthCredentials(xmpp_server_config_.username,
                                              oauth_refresh_token_,
                                              use_service_account_));
   oauth_token_getter_.reset(
       new OAuthTokenGetterImpl(std::move(oauth_credentials),
                                context_->url_request_context_getter(), false));
   signaling_connector_.reset(new SignalingConnector(
       xmpp_signal_strategy, std::move(dns_blackhole_checker),
       oauth_token_getter_.get(),
       base::Bind(&HostProcess::OnAuthFailed, base::Unretained(this))));
 
 #if defined(USE_GCD)
   // Create objects to manage GCD state.
   ServiceUrls* service_urls = ServiceUrls::GetInstance();
-  scoped_ptr<GcdRestClient> gcd_rest_client(new GcdRestClient(
+  std::unique_ptr<GcdRestClient> gcd_rest_client(new GcdRestClient(
       service_urls->gcd_base_url(), host_id_,
       context_->url_request_context_getter(), oauth_token_getter_.get()));
   gcd_state_updater_.reset(new GcdStateUpdater(
       base::Bind(&HostProcess::OnHeartbeatSuccessful, base::Unretained(this)),
       base::Bind(&HostProcess::OnUnknownHostIdError, base::Unretained(this)),
       signal_strategy_.get(), std::move(gcd_rest_client)));
   PushNotificationSubscriber::Subscription sub;
   sub.channel = "cloud_devices";
   PushNotificationSubscriber::SubscriptionList subs;
   subs.push_back(sub);
@@ skipping 46 matching lines @@
     // For legacy reasons we have to restrict the port range to a set of default
     // values when nat traversal is disabled, even if the port range was not
     // set in policy.
     network_settings.port_range.min_port = NetworkSettings::kDefaultMinPort;
     network_settings.port_range.max_port = 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(
               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();
   if (!desktop_environment_factory_->SupportsAudioCapture())
     protocol_config->DisableAudioChannel();
   if (enable_vp9_)
     protocol_config->set_vp9_experiment_enabled(true);
   protocol_config->set_webrtc_supported(true);
   session_manager->set_protocol_config(std::move(protocol_config));
 
   host_.reset(new ChromotingHost(desktop_environment_factory_.get(),
                                  std::move(session_manager), transport_context,
                                  context_->audio_task_runner(),
                                  context_->video_encode_task_runner()));
 
   if (gnubby_auth_policy_enabled_ && gnubby_extension_supported_) {
-    host_->AddExtension(make_scoped_ptr(new GnubbyExtension()));
+    host_->AddExtension(base::WrapUnique(new GnubbyExtension()));
   }
 
   // TODO(simonmorris): Get the maximum session duration from a policy.
 #if defined(OS_LINUX)
   host_->SetMaximumSessionDuration(base::TimeDelta::FromHours(20));
 #endif
 
   host_change_notification_listener_.reset(new HostChangeNotificationListener(
       this, host_id_, signal_strategy_.get(), directory_bot_jid_));
 
@@ skipping 158 matching lines @@
   // network thread. base::GetLinuxDistro() caches the result.
   base::GetLinuxDistro();
 #endif
 
   // Enable support for SSL server sockets, which must be done while still
   // single-threaded.
   net::EnableSSLServerSockets();
 
   // Create the main message loop and start helper threads.
   base::MessageLoopForUI message_loop;
-  scoped_ptr<ChromotingHostContext> context = ChromotingHostContext::Create(
-      new AutoThreadTaskRunner(message_loop.task_runner(),
-                               base::MessageLoop::QuitWhenIdleClosure()));
+  std::unique_ptr<ChromotingHostContext> context =
+      ChromotingHostContext::Create(
+          new AutoThreadTaskRunner(message_loop.task_runner(),
+                                   base::MessageLoop::QuitWhenIdleClosure()));
   if (!context)
     return kInitializationFailed;
 
   // NetworkChangeNotifier must be initialized after MessageLoop.
-  scoped_ptr<net::NetworkChangeNotifier> network_change_notifier(
+  std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier(
       net::NetworkChangeNotifier::Create());
 
   // Create & start the HostProcess using these threads.
   // TODO(wez): The HostProcess holds a reference to itself until Shutdown().
   // Remove this hack as part of the multi-process refactoring.
   int exit_code = kSuccessExitCode;
   ShutdownWatchdog shutdown_watchdog(
       base::TimeDelta::FromSeconds(kShutdownTimeoutSeconds));
   new HostProcess(std::move(context), &exit_code, &shutdown_watchdog);
 
   // Run the main (also UI) message loop until the host no longer needs it.
   message_loop.Run();
 
   return exit_code;
 }
 
 }  // namespace remoting