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

ios/chrome/browser/browser_state/chrome_browser_state_impl_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_impl_io_data.h"
 
 #include <set>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/pref_filter.h"
 #include "base/prefs/pref_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 42 matching lines @@
 ChromeBrowserStateImplIOData::Handle::~Handle() {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   if (io_data_->http_server_properties_manager_)
     io_data_->http_server_properties_manager_->ShutdownOnPrefThread();
 
   // io_data_->data_reduction_proxy_io_data() might be NULL if Init() was
   // never called.
   if (io_data_->data_reduction_proxy_io_data())
     io_data_->data_reduction_proxy_io_data()->ShutdownOnUIThread();
 
-  io_data_->ShutdownOnUIThread(GetAllContextGetters().Pass());
+  io_data_->ShutdownOnUIThread(GetAllContextGetters());
 }
 
 void ChromeBrowserStateImplIOData::Handle::Init(
     const base::FilePath& cookie_path,
     const base::FilePath& channel_id_path,
     const base::FilePath& cache_path,
     int cache_max_size,
     const base::FilePath& profile_path) {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
   DCHECK(!io_data_->lazy_params_);
@@ skipping 17 matching lines @@
   // params are unified into a single object.
   bool enable_quic_for_data_reduction_proxy =
       IOSChromeIOThread::ShouldEnableQuicForDataReductionProxy();
 
   io_data_->set_data_reduction_proxy_io_data(
       CreateIOSChromeDataReductionProxyIOData(
           GetApplicationContext()->GetIOSChromeIOThread()->net_log(),
           browser_state_->GetPrefs(),
           web::WebThread::GetTaskRunnerForThread(web::WebThread::IO),
           web::WebThread::GetTaskRunnerForThread(web::WebThread::UI),
-          enable_quic_for_data_reduction_proxy)
-          .Pass());
+          enable_quic_for_data_reduction_proxy));
 
   base::SequencedWorkerPool* pool = web::WebThread::GetBlockingPool();
   scoped_refptr<base::SequencedTaskRunner> db_task_runner =
       pool->GetSequencedTaskRunnerWithShutdownBehavior(
           pool->GetSequenceToken(),
           base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   scoped_ptr<data_reduction_proxy::DataStore> store(
       new data_reduction_proxy::DataStoreImpl(profile_path));
   IOSChromeDataReductionProxySettingsFactory::GetForBrowserState(browser_state_)
       ->InitDataReductionProxySettings(
           io_data_->data_reduction_proxy_io_data(), browser_state_->GetPrefs(),
-          browser_state_->GetRequestContext(), store.Pass(),
+          browser_state_->GetRequestContext(), std::move(store),
           web::WebThread::GetTaskRunnerForThread(web::WebThread::UI),
           db_task_runner);
 }
 
 scoped_refptr<IOSChromeURLRequestContextGetter>
 ChromeBrowserStateImplIOData::Handle::CreateMainRequestContextGetter(
     ProtocolHandlerMap* protocol_handlers,
     PrefService* local_state,
     IOSChromeIOThread* io_thread) const {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::UI);
@@ skipping 72 matching lines @@
   scoped_ptr<IOSChromeURLRequestContextGetterVector> context_getters(
       new IOSChromeURLRequestContextGetterVector());
 
   iter = app_request_context_getter_map_.begin();
   for (; iter != app_request_context_getter_map_.end(); ++iter)
     context_getters->push_back(iter->second);
 
   if (main_request_context_getter_.get())
     context_getters->push_back(main_request_context_getter_);
 
-  return context_getters.Pass();
+  return context_getters;
 }
 
 ChromeBrowserStateImplIOData::LazyParams::LazyParams() : cache_max_size(0) {}
 
 ChromeBrowserStateImplIOData::LazyParams::~LazyParams() {}
 
 ChromeBrowserStateImplIOData::ChromeBrowserStateImplIOData()
     : ChromeBrowserStateIOData(
           ios::ChromeBrowserStateType::REGULAR_BROWSER_STATE),
       http_server_properties_manager_(nullptr),
@@ skipping 22 matching lines @@
 
   ApplyProfileParamsToContext(main_context);
 
   if (http_server_properties_manager_)
     http_server_properties_manager_->InitializeOnNetworkThread();
 
   main_context->set_transport_security_state(transport_security_state());
 
   main_context->set_net_log(io_thread->net_log());
 
-  network_delegate_ =
-      data_reduction_proxy_io_data()
-          ->CreateNetworkDelegate(chrome_network_delegate.Pass(), true)
-          .Pass();
+  network_delegate_ = data_reduction_proxy_io_data()->CreateNetworkDelegate(
+      std::move(chrome_network_delegate), true);
 
   main_context->set_network_delegate(network_delegate_.get());
 
   main_context->set_http_server_properties(http_server_properties());
 
   main_context->set_host_resolver(io_thread_globals->host_resolver.get());
 
   main_context->set_http_auth_handler_factory(
       io_thread_globals->http_auth_handler_factory.get());
 
@@ skipping 40 matching lines @@
 
   set_channel_id_service(channel_id_service);
   main_context->set_channel_id_service(channel_id_service);
 
   scoped_ptr<net::HttpCache::BackendFactory> main_backend(
       new net::HttpCache::DefaultBackend(
           net::DISK_CACHE, net::CACHE_BACKEND_BLOCKFILE,
           lazy_params_->cache_path, lazy_params_->cache_max_size,
           web::WebThread::GetTaskRunnerForThread(web::WebThread::CACHE)));
   http_network_session_ = CreateHttpNetworkSession(*profile_params);
-  main_http_factory_ =
-      CreateMainHttpFactory(http_network_session_.get(), main_backend.Pass());
+  main_http_factory_ = CreateMainHttpFactory(http_network_session_.get(),
+                                             std::move(main_backend));
   main_context->set_http_transaction_factory(main_http_factory_.get());
 
   scoped_ptr<net::URLRequestJobFactoryImpl> main_job_factory(
       new net::URLRequestJobFactoryImpl());
   InstallProtocolHandlers(main_job_factory.get(), protocol_handlers);
 
   // The data reduction proxy interceptor should be as close to the network as
   // possible.
   URLRequestInterceptorScopedVector request_interceptors;
   request_interceptors.insert(
       request_interceptors.begin(),
       data_reduction_proxy_io_data()->CreateInterceptor().release());
-  main_job_factory_ = SetUpJobFactoryDefaults(main_job_factory.Pass(),
-                                              request_interceptors.Pass(),
+  main_job_factory_ = SetUpJobFactoryDefaults(std::move(main_job_factory),
+                                              std::move(request_interceptors),
                                               main_context->network_delegate());
   main_context->set_job_factory(main_job_factory_.get());
   main_context->set_network_quality_estimator(
       io_thread_globals->network_quality_estimator.get());
 
   // Setup SDCH for this profile.
   sdch_manager_.reset(new net::SdchManager);
   sdch_policy_.reset(new net::SdchOwner(sdch_manager_.get(), main_context));
   main_context->set_sdch_manager(sdch_manager_.get());
   sdch_policy_->EnablePersistentStorage(network_json_store_.get());
 
   lazy_params_.reset();
 }
 
 net::URLRequestContext*
 ChromeBrowserStateImplIOData::InitializeAppRequestContext(
     net::URLRequestContext* main_context) const {
   // Copy most state from the main context.
   AppRequestContext* context = new AppRequestContext();
   context->CopyFrom(main_context);
 
   // Use a separate HTTP disk cache for isolated apps.
   scoped_ptr<net::HttpCache::BackendFactory> app_backend =
       net::HttpCache::DefaultBackend::InMemory(0);
   scoped_ptr<net::HttpCache> app_http_cache =
-      CreateHttpFactory(http_network_session_.get(), app_backend.Pass());
+      CreateHttpFactory(http_network_session_.get(), std::move(app_backend));
 
   cookie_util::CookieStoreConfig ios_cookie_config(
       base::FilePath(),
       cookie_util::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES,
       cookie_util::CookieStoreConfig::COOKIE_STORE_IOS, nullptr);
   scoped_refptr<net::CookieStore> cookie_store =
       cookie_util::CreateCookieStore(ios_cookie_config);
 
   // Transfer ownership of the cookies and cache to AppRequestContext.
   context->SetCookieStore(cookie_store.get());
-  context->SetHttpTransactionFactory(app_http_cache.Pass());
+  context->SetHttpTransactionFactory(std::move(app_http_cache));
 
   scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
       new net::URLRequestJobFactoryImpl());
   // The data reduction proxy interceptor should be as close to the network as
   // possible.
   URLRequestInterceptorScopedVector request_interceptors;
   request_interceptors.insert(
       request_interceptors.begin(),
       data_reduction_proxy_io_data()->CreateInterceptor().release());
-  scoped_ptr<net::URLRequestJobFactory> top_job_factory(
-      SetUpJobFactoryDefaults(job_factory.Pass(), request_interceptors.Pass(),
-                              main_context->network_delegate()));
-  context->SetJobFactory(top_job_factory.Pass());
+  scoped_ptr<net::URLRequestJobFactory> top_job_factory(SetUpJobFactoryDefaults(
+      std::move(job_factory), std::move(request_interceptors),
+      main_context->network_delegate()));
+  context->SetJobFactory(std::move(top_job_factory));
 
   return context;
 }
 
 net::URLRequestContext*
 ChromeBrowserStateImplIOData::AcquireIsolatedAppRequestContext(
     net::URLRequestContext* main_context) const {
   // We create per-app contexts on demand, unlike the others above.
   net::URLRequestContext* app_request_context =
       InitializeAppRequestContext(main_context);
   DCHECK(app_request_context);
   return app_request_context;
 }
 
 void ChromeBrowserStateImplIOData::ClearNetworkingHistorySinceOnIOThread(
     base::Time time,
     const base::Closure& completion) {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::IO);
   DCHECK(initialized());
 
   DCHECK(transport_security_state());
   // Completes synchronously.
   transport_security_state()->DeleteAllDynamicDataSince(time);
   DCHECK(http_server_properties_manager_);
   http_server_properties_manager_->Clear(completion);
 }