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

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/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/logging.h"
 #include "remoting/base/rsa_key_pair.h"
@@ skipping 24 matching lines @@
 
 }  // namespace
 
 It2MeHost::It2MeHost(
     scoped_ptr<ChromotingHostContext> host_context,
     scoped_ptr<PolicyWatcher> policy_watcher,
     scoped_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory,
     base::WeakPtr<It2MeHost::Observer> observer,
     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
     const std::string& directory_bot_jid)
-    : host_context_(host_context.Pass()),
+    : 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),
-      policy_watcher_(policy_watcher.Pass()),
-      confirmation_dialog_factory_(confirmation_dialog_factory.Pass()),
+      policy_watcher_(std::move(policy_watcher)),
+      confirmation_dialog_factory_(std::move(confirmation_dialog_factory)),
       nat_traversal_enabled_(false),
       policy_received_(false) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 }
 
 void It2MeHost::Connect() {
   if (!host_context_->ui_task_runner()->BelongsToCurrentThread()) {
     DCHECK(task_runner_->BelongsToCurrentThread());
     host_context_->ui_task_runner()->PostTask(
         FROM_HERE, base::Bind(&It2MeHost::Connect, this));
@@ skipping 66 matching lines @@
       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(),
-                                       confirmation_dialog.Pass()));
+                                       std::move(confirmation_dialog)));
 
   confirmation_dialog_proxy_->Show(
       base::Bind(&It2MeHost::OnConfirmationResult, base::Unretained(this)));
 }
 
 void It2MeHost::OnConfirmationResult(It2MeConfirmationDialog::Result result) {
   switch (result) {
     case It2MeConfirmationDialog::Result::OK:
       ReadPolicyAndConnect();
       break;
@@ skipping 51 matching lines @@
                              xmpp_server_config_));
 
   // Request registration of the host for support.
   scoped_ptr<RegisterSupportHostRequest> register_request(
       new RegisterSupportHostRequest(
           signal_strategy.get(), host_key_pair_, directory_bot_jid_,
           base::Bind(&It2MeHost::OnReceivedSupportID,
                      base::Unretained(this))));
 
   // Beyond this point nothing can fail, so save the config and request.
-  signal_strategy_ = signal_strategy.Pass();
-  register_request_ = register_request.Pass();
+  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_ptr<protocol::TransportFactory> transport_factory(
       new protocol::IceTransportFactory(new protocol::TransportContext(
           signal_strategy_.get(),
           make_scoped_ptr(new protocol::ChromiumPortAllocatorFactory(
               host_context_->url_request_context_getter())),
           network_settings, protocol::TransportRole::SERVER)));
 
   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();
   // Disable audio by default.
   // TODO(sergeyu): Add UI to enable it.
   protocol_config->DisableAudioChannel();
-  session_manager->set_protocol_config(protocol_config.Pass());
+  session_manager->set_protocol_config(std::move(protocol_config));
 
   // Create the host.
   host_.reset(new ChromotingHost(
-      desktop_environment_factory_.get(),
-      session_manager.Pass(), host_context_->audio_task_runner(),
-      host_context_->input_task_runner(),
+      desktop_environment_factory_.get(), std::move(session_manager),
+      host_context_->audio_task_runner(), host_context_->input_task_runner(),
       host_context_->video_capture_task_runner(),
       host_context_->video_encode_task_runner(),
       host_context_->network_task_runner(), host_context_->ui_task_runner()));
   host_->AddStatusObserver(this);
   host_status_logger_.reset(
       new HostStatusLogger(host_->AsWeakPtr(), ServerLogEntry::IT2ME,
                            signal_strategy_.get(), directory_bot_jid_));
 
   // Create event logger.
   host_event_logger_ =
@@ skipping 183 matching lines @@
     std::string error_message = "Failed to generate host certificate.";
     LOG(ERROR) << error_message;
     SetState(kError, error_message);
     Shutdown();
     return;
   }
 
   scoped_ptr<protocol::AuthenticatorFactory> factory(
       new protocol::It2MeHostAuthenticatorFactory(
           local_certificate, host_key_pair_, access_code));
-  host_->SetAuthenticatorFactory(factory.Pass());
+  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) {
@@ skipping 12 matching lines @@
     scoped_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(
       new It2MeConfirmationDialogFactory());
   scoped_ptr<PolicyWatcher> policy_watcher =
       PolicyWatcher::Create(policy_service_, context->file_task_runner());
-  return new It2MeHost(context.Pass(), policy_watcher.Pass(),
-                       confirmation_dialog_factory.Pass(),
-                       observer, xmpp_server_config, directory_bot_jid);
+  return new It2MeHost(std::move(context), std::move(policy_watcher),
+                       std::move(confirmation_dialog_factory), observer,
+                       xmpp_server_config, directory_bot_jid);
 }
 
 }  // namespace remoting