Convert Pass()→std::move() for iOS build.

ios/chrome/browser/ios_chrome_io_thread.cc

 // Copyright 2015 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 "ios/chrome/browser/ios_chrome_io_thread.h"
 
 #include <stddef.h>
 
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/leak_tracker.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 122 matching lines @@
       *base::CommandLine::ForCurrentProcess();
 
   scoped_ptr<net::HostResolver> global_host_resolver =
       net::HostResolver::CreateSystemResolver(net::HostResolver::Options(),
                                               net_log);
 
   // If hostname remappings were specified on the command-line, layer these
   // rules on top of the real host resolver. This allows forwarding all requests
   // through a designated test server.
   if (!command_line.HasSwitch(switches::kIOSHostResolverRules))
-    return global_host_resolver.Pass();
+    return global_host_resolver;
 
   scoped_ptr<net::MappedHostResolver> remapped_resolver(
-      new net::MappedHostResolver(global_host_resolver.Pass()));
+      new net::MappedHostResolver(std::move(global_host_resolver)));
   remapped_resolver->SetRulesFromString(
       command_line.GetSwitchValueASCII(switches::kIOSHostResolverRules));
-  return remapped_resolver.Pass();
+  return std::move(remapped_resolver);
 }
 
 int GetSwitchValueAsInt(const base::CommandLine& command_line,
                         const std::string& switch_name) {
   int value;
   if (!base::StringToInt(command_line.GetSwitchValueASCII(switch_name),
                          &value)) {
     return 0;
   }
   return value;
@@ skipping 207 matching lines @@
   // Assuming NetworkChangeNotifier dispatches in FIFO order, we should be
   // logging the network change before other IO thread consumers respond to it.
   network_change_observer_.reset(new LoggingNetworkChangeObserver(net_log_));
 
   // Setup the HistogramWatcher to run on the IO thread.
   net::NetworkChangeNotifier::InitHistogramWatcher();
 
   scoped_ptr<IOSChromeNetworkDelegate> chrome_network_delegate(
       new IOSChromeNetworkDelegate());
 
-  globals_->system_network_delegate = chrome_network_delegate.Pass();
+  globals_->system_network_delegate = std::move(chrome_network_delegate);
   globals_->host_resolver = CreateGlobalHostResolver(net_log_);
 
   std::map<std::string, std::string> network_quality_estimator_params;
   variations::GetVariationParams(kNetworkQualityEstimatorFieldTrialName,
                                  &network_quality_estimator_params);
 
   scoped_ptr<net::ExternalEstimateProvider> external_estimate_provider;
   // Pass ownership.
   globals_->network_quality_estimator.reset(new net::NetworkQualityEstimator(
-      external_estimate_provider.Pass(), network_quality_estimator_params));
+      std::move(external_estimate_provider), network_quality_estimator_params));
 
   globals_->cert_verifier.reset(
       new net::MultiThreadedCertVerifier(net::CertVerifyProc::CreateDefault()));
 
   globals_->transport_security_state.reset(new net::TransportSecurityState());
 
   std::vector<scoped_refptr<const net::CTLogVerifier>> ct_logs(
       net::ct::CreateLogVerifiersForKnownLogs());
 
   net::MultiLogCTVerifier* ct_verifier = new net::MultiLogCTVerifier();
@@ skipping 161 matching lines @@
 }
 
 void IOSChromeIOThread::CreateDefaultAuthHandlerFactory() {
   std::vector<std::string> supported_schemes =
       base::SplitString(kSupportedAuthSchemes, ",", base::TRIM_WHITESPACE,
                         base::SPLIT_WANT_NONEMPTY);
   globals_->http_auth_preferences.reset(
       new net::HttpAuthPreferences(supported_schemes, std::string()));
   globals_->http_auth_handler_factory =
       net::HttpAuthHandlerRegistryFactory::Create(
-          globals_->http_auth_preferences.get(), globals_->host_resolver.get())
-          .Pass();
+          globals_->http_auth_preferences.get(), globals_->host_resolver.get());
 }
 
 void IOSChromeIOThread::ClearHostCache() {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::IO);
 
   net::HostCache* host_cache = globals_->host_resolver->GetHostCache();
   if (host_cache)
     host_cache->clear();
 }
 
@@ skipping 96 matching lines @@
                  base::Unretained(this)));
 }
 
 void IOSChromeIOThread::InitSystemRequestContextOnIOThread() {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::IO);
   DCHECK(!globals_->system_proxy_service.get());
   DCHECK(system_proxy_config_service_.get());
 
   globals_->system_proxy_service = ios::ProxyServiceFactory::CreateProxyService(
       net_log_, nullptr, globals_->system_network_delegate.get(),
-      system_proxy_config_service_.Pass(), true /* quick_check_enabled */);
+      std::move(system_proxy_config_service_), true /* quick_check_enabled */);
 
   globals_->system_request_context.reset(
       ConstructSystemRequestContext(globals_, net_log_));
 }
 
 void IOSChromeIOThread::ConfigureQuic() {
   // Always fetch the field trial group to ensure it is reported correctly.
   // The command line flags will be associated with a group that is reported
   // so long as trial is actually queried.
   std::string group = base::FieldTrialList::FindFullName(kQuicFieldTrialName);
@@ skipping 304 matching lines @@
 
   globals->system_http_network_session.reset(
       new net::HttpNetworkSession(system_params));
   globals->system_http_transaction_factory.reset(
       new net::HttpNetworkLayer(globals->system_http_network_session.get()));
   context->set_http_transaction_factory(
       globals->system_http_transaction_factory.get());
 
   return context;
 }