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

ios/chrome/browser/browser_state/chrome_browser_state_io_data.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/browser_state/chrome_browser_state_io_data.h"
 
 #include <stddef.h>
 
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/path_service.h"
@@ skipping 113 matching lines @@
 ChromeBrowserStateIOData::AppRequestContext::AppRequestContext() {}
 
 void ChromeBrowserStateIOData::AppRequestContext::SetCookieStore(
     net::CookieStore* cookie_store) {
   cookie_store_ = cookie_store;
   set_cookie_store(cookie_store);
 }
 
 void ChromeBrowserStateIOData::AppRequestContext::SetHttpTransactionFactory(
     scoped_ptr<net::HttpTransactionFactory> http_factory) {
-  http_factory_ = http_factory.Pass();
+  http_factory_ = std::move(http_factory);
   set_http_transaction_factory(http_factory_.get());
 }
 
 void ChromeBrowserStateIOData::AppRequestContext::SetJobFactory(
     scoped_ptr<net::URLRequestJobFactory> job_factory) {
-  job_factory_ = job_factory.Pass();
+  job_factory_ = std::move(job_factory);
   set_job_factory(job_factory_.get());
 }
 
 ChromeBrowserStateIOData::AppRequestContext::~AppRequestContext() {
   AssertNoURLRequests();
 }
 
 ChromeBrowserStateIOData::ProfileParams::ProfileParams()
     : io_thread(nullptr), browser_state(nullptr) {}
 
@@ skipping 141 matching lines @@
 }
 
 bool ChromeBrowserStateIOData::IsDataReductionProxyEnabled() const {
   return data_reduction_proxy_io_data() &&
          data_reduction_proxy_io_data()->IsEnabled();
 }
 
 void ChromeBrowserStateIOData::set_data_reduction_proxy_io_data(
     scoped_ptr<data_reduction_proxy::DataReductionProxyIOData>
         data_reduction_proxy_io_data) const {
-  data_reduction_proxy_io_data_ = data_reduction_proxy_io_data.Pass();
+  data_reduction_proxy_io_data_ = std::move(data_reduction_proxy_io_data);
 }
 
 base::WeakPtr<net::HttpServerProperties>
 ChromeBrowserStateIOData::http_server_properties() const {
   return http_server_properties_->GetWeakPtr();
 }
 
 void ChromeBrowserStateIOData::set_http_server_properties(
     scoped_ptr<net::HttpServerProperties> http_server_properties) const {
-  http_server_properties_ = http_server_properties.Pass();
+  http_server_properties_ = std::move(http_server_properties);
 }
 
 void ChromeBrowserStateIOData::Init(
     ProtocolHandlerMap* protocol_handlers) const {
   // The basic logic is implemented here. The specific initialization
   // is done in InitializeInternal(), implemented by subtypes. Static helper
   // functions have been provided to assist in common operations.
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::IO);
   DCHECK(!initialized_);
 
@@ skipping 13 matching lines @@
       new IOSChromeNetworkDelegate());
 
   network_delegate->set_cookie_settings(profile_params_->cookie_settings.get());
   network_delegate->set_enable_do_not_track(&enable_do_not_track_);
 
   // NOTE: Proxy service uses the default io thread network delegate, not the
   // delegate just created.
   proxy_service_ = ios::ProxyServiceFactory::CreateProxyService(
       io_thread->net_log(), nullptr,
       io_thread_globals->system_network_delegate.get(),
-      profile_params_->proxy_config_service.Pass(),
+      std::move(profile_params_->proxy_config_service),
       true /* quick_check_enabled */);
   transport_security_state_.reset(new net::TransportSecurityState());
   base::SequencedWorkerPool* pool = web::WebThread::GetBlockingPool();
   transport_security_persister_.reset(new net::TransportSecurityPersister(
       transport_security_state_.get(), profile_params_->path,
       pool->GetSequencedTaskRunnerWithShutdownBehavior(
           pool->GetSequenceToken(), base::SequencedWorkerPool::BLOCK_SHUTDOWN),
       IsOffTheRecord()));
 
   certificate_report_sender_.reset(new net::CertificateReportSender(
       main_request_context_.get(),
       net::CertificateReportSender::DO_NOT_SEND_COOKIES));
   transport_security_state_->SetReportSender(certificate_report_sender_.get());
 
   // Take ownership over these parameters.
   cookie_settings_ = profile_params_->cookie_settings;
   host_content_settings_map_ = profile_params_->host_content_settings_map;
 
   main_request_context_->set_cert_verifier(
       io_thread_globals->cert_verifier.get());
 
-  InitializeInternal(network_delegate.Pass(), profile_params_.get(),
+  InitializeInternal(std::move(network_delegate), profile_params_.get(),
                      protocol_handlers);
 
   profile_params_.reset();
   initialized_ = true;
 }
 
 void ChromeBrowserStateIOData::ApplyProfileParamsToContext(
     net::URLRequestContext* context) const {
   context->set_http_user_agent_settings(chrome_http_user_agent_settings_.get());
   context->set_ssl_config_service(profile_params_->ssl_config_service.get());
@@ skipping 15 matching lines @@
 
   set_protocol = job_factory->SetProtocolHandler(
       url::kDataScheme, make_scoped_ptr(new net::DataProtocolHandler()));
   DCHECK(set_protocol);
 
   job_factory->SetProtocolHandler(
       url::kAboutScheme,
       make_scoped_ptr(new about_handler::AboutProtocolHandler()));
 
   // Set up interceptors in the reverse order.
-  scoped_ptr<net::URLRequestJobFactory> top_job_factory = job_factory.Pass();
+  scoped_ptr<net::URLRequestJobFactory> top_job_factory =
+      std::move(job_factory);
   for (URLRequestInterceptorScopedVector::reverse_iterator i =
            request_interceptors.rbegin();
        i != request_interceptors.rend(); ++i) {
     top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
-        top_job_factory.Pass(), make_scoped_ptr(*i)));
+        std::move(top_job_factory), make_scoped_ptr(*i)));
   }
   request_interceptors.weak_clear();
-  return top_job_factory.Pass();
+  return top_job_factory;
 }
 
 void ChromeBrowserStateIOData::ShutdownOnUIThread(
     scoped_ptr<IOSChromeURLRequestContextGetterVector> context_getters) {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
 
   google_services_user_account_id_.Destroy();
   enable_referrers_.Destroy();
   enable_do_not_track_.Destroy();
   enable_metrics_.Destroy();
@@ skipping 40 matching lines @@
     params.proxy_delegate = data_reduction_proxy_io_data_->proxy_delegate();
 
   return scoped_ptr<net::HttpNetworkSession>(
       new net::HttpNetworkSession(params));
 }
 
 scoped_ptr<net::HttpCache> ChromeBrowserStateIOData::CreateMainHttpFactory(
     net::HttpNetworkSession* session,
     scoped_ptr<net::HttpCache::BackendFactory> main_backend) const {
   return scoped_ptr<net::HttpCache>(
-      new net::HttpCache(session, main_backend.Pass(), true));
+      new net::HttpCache(session, std::move(main_backend), true));
 }
 
 scoped_ptr<net::HttpCache> ChromeBrowserStateIOData::CreateHttpFactory(
     net::HttpNetworkSession* shared_session,
     scoped_ptr<net::HttpCache::BackendFactory> backend) const {
   return scoped_ptr<net::HttpCache>(
-      new net::HttpCache(shared_session, backend.Pass(), true));
+      new net::HttpCache(shared_session, std::move(backend), true));
 }