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

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 <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/message_loop/message_loop.h"
@@ skipping 443 matching lines @@
   scoped_refptr<PairingRegistry> pairing_registry_;
 
   ShutdownWatchdog* shutdown_watchdog_;
 
   DISALLOW_COPY_AND_ASSIGN(HostProcess);
 };
 
 HostProcess::HostProcess(scoped_ptr<ChromotingHostContext> context,
                          int* exit_code_out,
                          ShutdownWatchdog* shutdown_watchdog)
-    : context_(context.Pass()),
+    : context_(std::move(context)),
       state_(HOST_STARTING),
       use_service_account_(false),
       enable_vp9_(false),
       frame_recorder_buffer_size_(0),
       policy_state_(POLICY_INITIALIZING),
       host_username_match_required_(false),
       allow_nat_traversal_(true),
       allow_relay_(true),
       allow_pairing_(true),
       curtain_required_(false),
@@ skipping 288 matching lines @@
     if (allow_pairing_) {
       // On Windows |pairing_registry_| is initialized in
       // InitializePairingRegistry().
 #if !defined(OS_WIN)
       if (!pairing_registry_) {
         scoped_ptr<PairingRegistry::Delegate> delegate =
             CreatePairingRegistryDelegate();
 
         if (delegate)
           pairing_registry_ = new PairingRegistry(context_->file_task_runner(),
-                                                  delegate.Pass());
+                                                  std::move(delegate));
       }
 #endif  // defined(OS_WIN)
 
       pairing_registry = pairing_registry_;
     }
 
     factory = protocol::Me2MeHostAuthenticatorFactory::CreateWithSharedSecret(
         use_service_account_, host_owner_, local_certificate, key_pair_,
         host_secret_hash_, pairing_registry);
 
     host_->set_pairing_registry(pairing_registry);
   } else {
     DCHECK(third_party_auth_config_.token_url.is_valid());
     DCHECK(third_party_auth_config_.token_validation_url.is_valid());
 
     scoped_ptr<protocol::TokenValidatorFactory> token_validator_factory(
         new TokenValidatorFactoryImpl(
             third_party_auth_config_,
             key_pair_, context_->url_request_context_getter()));
     factory = protocol::Me2MeHostAuthenticatorFactory::CreateWithThirdPartyAuth(
         use_service_account_, host_owner_, local_certificate, key_pair_,
-        token_validator_factory.Pass());
+        std::move(token_validator_factory));
   }
 
 #if defined(OS_POSIX)
   // On Linux and Mac, perform a PAM authorization step after authentication.
-  factory.reset(new PamAuthorizationFactory(factory.Pass()));
+  factory.reset(new PamAuthorizationFactory(std::move(factory)));
 #endif
-  host_->SetAuthenticatorFactory(factory.Pass());
+  host_->SetAuthenticatorFactory(std::move(factory));
 }
 
 // IPC::Listener implementation.
 bool HostProcess::OnMessageReceived(const IPC::Message& message) {
   DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
 #if defined(REMOTING_MULTI_PROCESS)
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(HostProcess, message)
     IPC_MESSAGE_HANDLER(ChromotingDaemonMsg_Crash, OnCrash)
@@ skipping 167 matching lines @@
   HKEY privileged_hkey = reinterpret_cast<HKEY>(
       IPC::PlatformFileForTransitToPlatformFile(privileged_key));
   HKEY unprivileged_hkey = reinterpret_cast<HKEY>(
       IPC::PlatformFileForTransitToPlatformFile(unprivileged_key));
 
   scoped_ptr<PairingRegistryDelegateWin> delegate(
       new PairingRegistryDelegateWin());
   delegate->SetRootKeys(privileged_hkey, unprivileged_hkey);
 
   pairing_registry_ = new PairingRegistry(context_->file_task_runner(),
-                                          delegate.Pass());
+                                          std::move(delegate));
 
   // (Re)Create the authenticator factory now that |pairing_registry_| has been
   // initialized.
   CreateAuthenticatorFactory();
 }
 #endif  // !defined(OS_WIN)
 
 // Applies the host config, returning true if successful.
 bool HostProcess::ApplyConfig(const base::DictionaryValue& config) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
@@ skipping 407 matching lines @@
       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(
       new OAuthTokenGetter::OAuthCredentials(xmpp_server_config_.username,
                                              oauth_refresh_token_,
                                              use_service_account_));
-  oauth_token_getter_.reset(new OAuthTokenGetterImpl(
-      oauth_credentials.Pass(), context_->url_request_context_getter(), false));
+  oauth_token_getter_.reset(
+      new OAuthTokenGetterImpl(std::move(oauth_credentials),
+                               context_->url_request_context_getter(), false));
   signaling_connector_.reset(new SignalingConnector(
-      xmpp_signal_strategy, dns_blackhole_checker.Pass(),
+      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(
       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(), gcd_rest_client.Pass()));
+  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);
   gcd_subscriber_.reset(
       new PushNotificationSubscriber(signal_strategy_.get(), subs));
 #endif  // defined(USE_GCD)
 
   // Create HeartbeatSender.
   heartbeat_sender_.reset(new HeartbeatSender(
@@ skipping 64 matching lines @@
 #else  // !defined(NDEBUG)
     LOG(ERROR) << "WebRTC is enabled only in debug builds.";
     ShutdownHost(kUsageExitCode);
     return;
 #endif  // defined(NDEBUG)
   } else {
     transport_factory.reset(
         new protocol::IceTransportFactory(transport_context));
   }
   scoped_ptr<protocol::SessionManager> session_manager(
-      new protocol::JingleSessionManager(transport_factory.Pass(),
+      new protocol::JingleSessionManager(std::move(transport_factory),
                                          signal_strategy_.get()));
 
   scoped_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);
 #if !defined(NDEBUG)
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kEnableWebrtc)) {
     protocol_config->set_webrtc_supported(true);
   }
 #endif  // !defined(NDEBUG)
-  session_manager->set_protocol_config(protocol_config.Pass());
+  session_manager->set_protocol_config(std::move(protocol_config));
 
   host_.reset(new ChromotingHost(
-      desktop_environment_factory_.get(),
-      session_manager.Pass(), context_->audio_task_runner(),
-      context_->input_task_runner(), context_->video_capture_task_runner(),
+      desktop_environment_factory_.get(), std::move(session_manager),
+      context_->audio_task_runner(), context_->input_task_runner(),
+      context_->video_capture_task_runner(),
       context_->video_encode_task_runner(), context_->network_task_runner(),
       context_->ui_task_runner()));
 
   if (frame_recorder_buffer_size_ > 0) {
     scoped_ptr<VideoFrameRecorderHostExtension> frame_recorder_extension(
         new VideoFrameRecorderHostExtension());
     frame_recorder_extension->SetMaxContentBytes(frame_recorder_buffer_size_);
-    host_->AddExtension(frame_recorder_extension.Pass());
+    host_->AddExtension(std::move(frame_recorder_extension));
   }
 
   // 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 174 matching lines @@
   // NetworkChangeNotifier must be initialized after MessageLoop.
   scoped_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(context.Pass(), &exit_code, &shutdown_watchdog);
+  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