Convert Pass()→std::move() in //google_apis

google_apis/gcm/tools/mcs_probe.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.
 //
 // A standalone tool for testing MCS connections and the MCS client on their
 // own.
 
 #include <stdint.h>
-
 #include <cstddef>
 #include <cstdio>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 326 matching lines @@
                                      secret_,
                                      base::Bind(&MCSProbe::UpdateCallback,
                                                 base::Unretained(this)));
   } else {
     android_id_ = load_result->device_android_id;
     secret_ = load_result->device_security_token;
     DVLOG(1) << "Loaded MCS id " << android_id_;
   }
   mcs_client_->Initialize(
       base::Bind(&MCSProbe::ErrorCallback, base::Unretained(this)),
-      base::Bind(&MessageReceivedCallback),
-      base::Bind(&MessageSentCallback),
-      load_result.Pass());
+      base::Bind(&MessageReceivedCallback), base::Bind(&MessageSentCallback),
+      std::move(load_result));
 
   if (!android_id_ || !secret_) {
     DVLOG(1) << "Checkin to generate new MCS credentials.";
     CheckIn();
     return;
   }
 
   StartMCSLogin();
 }
 
 void MCSProbe::UpdateCallback(bool success) {
 }
 
 void MCSProbe::InitializeNetworkState() {
   base::ScopedFILE log_file;
   if (command_line_.HasSwitch(kLogFileSwitch)) {
     base::FilePath log_path = command_line_.GetSwitchValuePath(kLogFileSwitch);
 #if defined(OS_WIN)
     log_file.reset(_wfopen(log_path.value().c_str(), L"w"));
 #elif defined(OS_POSIX)
     log_file.reset(fopen(log_path.value().c_str(), "w"));
 #endif
   }
   if (log_file.get()) {
     logger_.reset(new net::WriteToFileNetLogObserver());
     logger_->set_capture_mode(
         net::NetLogCaptureMode::IncludeCookiesAndCredentials());
-    logger_->StartObserving(&net_log_, log_file.Pass(), nullptr, nullptr);
+    logger_->StartObserving(&net_log_, std::move(log_file), nullptr, nullptr);
   }
 
   host_resolver_ = net::HostResolver::CreateDefaultResolver(&net_log_);
 
   if (command_line_.HasSwitch(kIgnoreCertSwitch)) {
     cert_verifier_.reset(new MyTestCertVerifier());
   } else {
     cert_verifier_ = net::CertVerifier::CreateDefault();
   }
   system_channel_id_service_.reset(
       new net::ChannelIDService(
           new net::DefaultChannelIDStore(NULL),
           base::WorkerPool::GetTaskRunner(true)));
 
   transport_security_state_.reset(new net::TransportSecurityState());
-  http_auth_handler_factory_ =
-      net::HttpAuthHandlerRegistryFactory::Create(&http_auth_preferences_,
-                                                  host_resolver_.get())
-          .Pass();
+  http_auth_handler_factory_ = net::HttpAuthHandlerRegistryFactory::Create(
+      &http_auth_preferences_, host_resolver_.get());
   http_server_properties_.reset(new net::HttpServerPropertiesImpl());
   host_mapping_rules_.reset(new net::HostMappingRules());
   proxy_service_ = net::ProxyService::CreateDirectWithNetLog(&net_log_);
 }
 
 void MCSProbe::BuildNetworkSession() {
   net::HttpNetworkSession::Params session_params;
   session_params.host_resolver = host_resolver_.get();
   session_params.cert_verifier = cert_verifier_.get();
   session_params.channel_id_service = system_channel_id_service_.get();
@@ skipping 97 matching lines @@
 
   return 0;
 }
 
 }  // namespace
 }  // namespace gcm
 
 int main(int argc, char* argv[]) {
   return gcm::MCSProbeMain(argc, argv);
 }