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

chrome/browser/profiles/profile_impl_io_data.cc

 // Copyright (c) 2012 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 "chrome/browser/profiles/profile_impl_io_data.h"
 
 #include <set>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/pref_filter.h"
 #include "base/prefs/pref_member.h"
@@ skipping 102 matching lines @@
   }
 
   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 ProfileImplIOData::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& media_cache_path,
     int media_cache_max_size,
     const base::FilePath& extensions_cookie_path,
@@ skipping 21 matching lines @@
 
   io_data_->lazy_params_.reset(lazy_params);
 
   // Keep track of profile path and cache sizes separately so we can use them
   // on demand when creating storage isolated URLRequestContextGetters.
   io_data_->profile_path_ = profile_path;
   io_data_->app_cache_max_size_ = cache_max_size;
   io_data_->app_media_cache_max_size_ = media_cache_max_size;
 
   io_data_->predictor_.reset(predictor);
-  io_data_->domain_reliability_monitor_ = domain_reliability_monitor.Pass();
+  io_data_->domain_reliability_monitor_ = std::move(domain_reliability_monitor);
 
   io_data_->InitializeMetricsEnabledStateOnUIThread();
   if (io_data_->domain_reliability_monitor_)
     io_data_->domain_reliability_monitor_->MoveToNetworkThread();
 
   // TODO(tbansal): Move this to IO thread once the data reduction proxy
   // params are unified into a single object.
   bool enable_quic_for_data_reduction_proxy =
       IOThread::ShouldEnableQuicForDataReductionProxy();
 
   io_data_->set_data_reduction_proxy_io_data(
       CreateDataReductionProxyChromeIOData(
           g_browser_process->io_thread()->net_log(), profile_->GetPrefs(),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
-          enable_quic_for_data_reduction_proxy)
-          .Pass());
+          enable_quic_for_data_reduction_proxy));
 
   base::SequencedWorkerPool* pool = BrowserThread::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));
   DataReductionProxyChromeSettingsFactory::GetForBrowserContext(profile_)
       ->InitDataReductionProxySettings(
           io_data_->data_reduction_proxy_io_data(), profile_->GetPrefs(),
-          profile_->GetRequestContext(), store.Pass(),
+          profile_->GetRequestContext(), std::move(store),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
           db_task_runner);
 }
 
 content::ResourceContext*
     ProfileImplIOData::Handle::GetResourceContext() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   LazyInitialize();
   return GetResourceContextNoInit();
 }
@@ skipping 10 matching lines @@
 scoped_refptr<ChromeURLRequestContextGetter>
 ProfileImplIOData::Handle::CreateMainRequestContextGetter(
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector request_interceptors,
     PrefService* local_state,
     IOThread* io_thread) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   LazyInitialize();
   DCHECK(!main_request_context_getter_.get());
   main_request_context_getter_ = ChromeURLRequestContextGetter::Create(
-      profile_, io_data_, protocol_handlers, request_interceptors.Pass());
+      profile_, io_data_, protocol_handlers, std::move(request_interceptors));
 
   io_data_->predictor_
       ->InitNetworkPredictor(profile_->GetPrefs(),
                              local_state,
                              io_thread,
                              main_request_context_getter_.get(),
                              io_data_);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_URL_REQUEST_CONTEXT_GETTER_INITIALIZED,
@@ skipping 42 matching lines @@
       app_request_context_getter_map_.find(descriptor);
   if (iter != app_request_context_getter_map_.end())
     return iter->second;
 
   scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
       protocol_handler_interceptor(
           ProtocolHandlerRegistryFactory::GetForBrowserContext(profile_)->
               CreateJobInterceptorFactory());
   ChromeURLRequestContextGetter* context =
       ChromeURLRequestContextGetter::CreateForIsolatedApp(
-          profile_,
-          io_data_,
-          descriptor,
-          protocol_handler_interceptor.Pass(),
-          protocol_handlers,
-          request_interceptors.Pass());
+          profile_, io_data_, descriptor,
+          std::move(protocol_handler_interceptor), protocol_handlers,
+          std::move(request_interceptors));
   app_request_context_getter_map_[descriptor] = context;
 
   return context;
 }
 
 scoped_refptr<ChromeURLRequestContextGetter>
 ProfileImplIOData::Handle::GetIsolatedMediaRequestContextGetter(
     const base::FilePath& partition_path,
     bool in_memory) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 86 matching lines @@
 
   if (extensions_request_context_getter_.get())
     context_getters->push_back(extensions_request_context_getter_);
 
   if (media_request_context_getter_.get())
     context_getters->push_back(media_request_context_getter_);
 
   if (main_request_context_getter_.get())
     context_getters->push_back(main_request_context_getter_);
 
-  return context_getters.Pass();
+  return context_getters;
 }
 
 ProfileImplIOData::LazyParams::LazyParams()
     : cache_max_size(0),
       media_cache_max_size(0),
       session_cookie_mode(
           content::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES) {}
 
 ProfileImplIOData::LazyParams::~LazyParams() {}
 
@@ skipping 45 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();
+      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 @@
 
   scoped_ptr<net::HttpCache::BackendFactory> main_backend(
       new net::HttpCache::DefaultBackend(
           net::DISK_CACHE,
           ChooseCacheBackendType(),
           lazy_params_->cache_path,
           lazy_params_->cache_max_size,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)));
   http_network_session_ = CreateHttpNetworkSession(*profile_params);
   main_http_factory_ = CreateMainHttpFactory(http_network_session_.get(),
-                                             main_backend.Pass());
+                                             std::move(main_backend));
   main_context->set_http_transaction_factory(main_http_factory_.get());
 
 #if !defined(DISABLE_FTP_SUPPORT)
   ftp_factory_.reset(
       new net::FtpNetworkLayer(io_thread_globals->host_resolver.get()));
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
   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.
   request_interceptors.insert(
       request_interceptors.begin(),
       data_reduction_proxy_io_data()->CreateInterceptor().release());
   main_job_factory_ = SetUpJobFactoryDefaults(
-      main_job_factory.Pass(),
-      request_interceptors.Pass(),
-      profile_params->protocol_handler_interceptor.Pass(),
-      main_context->network_delegate(),
-      ftp_factory_.get());
+      std::move(main_job_factory), std::move(request_interceptors),
+      std::move(profile_params->protocol_handler_interceptor),
+      main_context->network_delegate(), ftp_factory_.get());
   main_context->set_job_factory(main_job_factory_.get());
   main_context->set_network_quality_estimator(
       io_thread_globals->network_quality_estimator.get());
 
 #if defined(ENABLE_EXTENSIONS)
   InitializeExtensionsRequestContext(profile_params);
 #endif
 
   // Setup SDCH for this profile.
   sdch_manager_.reset(new net::SdchManager);
@@ skipping 38 matching lines @@
 
   scoped_ptr<net::URLRequestJobFactoryImpl> extensions_job_factory(
       new net::URLRequestJobFactoryImpl());
   // TODO(shalev): The extensions_job_factory has a NULL NetworkDelegate.
   // Without a network_delegate, this protocol handler will never
   // handle file: requests, but as a side effect it makes
   // job_factory::IsHandledProtocol return true, which prevents attempts to
   // handle the protocol externally. We pass NULL in to
   // SetUpJobFactory() to get this effect.
   extensions_job_factory_ = SetUpJobFactoryDefaults(
-      extensions_job_factory.Pass(),
+      std::move(extensions_job_factory),
       content::URLRequestInterceptorScopedVector(),
-      scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>(),
-      NULL,
+      scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>(), NULL,
       ftp_factory_.get());
   extensions_context->set_job_factory(extensions_job_factory_.get());
   extensions_context->set_backoff_manager(
       io_thread_globals->url_request_backoff_manager.get());
 }
 
 net::URLRequestContext* ProfileImplIOData::InitializeAppRequestContext(
     net::URLRequestContext* main_context,
     const StoragePartitionDescriptor& partition_descriptor,
     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
@@ skipping 15 matching lines @@
     app_backend = net::HttpCache::DefaultBackend::InMemory(0);
   } else {
     app_backend.reset(new net::HttpCache::DefaultBackend(
         net::DISK_CACHE,
         ChooseCacheBackendType(),
         cache_path,
         app_cache_max_size_,
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)));
   }
   scoped_ptr<net::HttpCache> app_http_cache =
-      CreateHttpFactory(http_network_session_.get(), app_backend.Pass());
+      CreateHttpFactory(http_network_session_.get(), std::move(app_backend));
 
   scoped_refptr<net::CookieStore> cookie_store = NULL;
   if (partition_descriptor.in_memory) {
     cookie_store = content::CreateCookieStore(content::CookieStoreConfig());
   }
 
   // Use an app-specific cookie store.
   if (!cookie_store.get()) {
     DCHECK(!cookie_path.empty());
 
     // TODO(creis): We should have a cookie delegate for notifying the cookie
     // extensions API, but we need to update it to understand isolated apps
     // first.
     content::CookieStoreConfig cookie_config(
         cookie_path,
         content::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES,
         NULL, NULL);
     cookie_config.crypto_delegate = cookie_config::GetCookieCryptoDelegate();
     cookie_store = content::CreateCookieStore(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());
   InstallProtocolHandlers(job_factory.get(), protocol_handlers);
   // The data reduction proxy interceptor should be as close to the network
   // as possible.
   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(),
-                              protocol_handler_interceptor.Pass(),
-                              main_context->network_delegate(),
-                              ftp_factory_.get()));
-  context->SetJobFactory(top_job_factory.Pass());
+  scoped_ptr<net::URLRequestJobFactory> top_job_factory(SetUpJobFactoryDefaults(
+      std::move(job_factory), std::move(request_interceptors),
+      std::move(protocol_handler_interceptor), main_context->network_delegate(),
+      ftp_factory_.get()));
+  context->SetJobFactory(std::move(top_job_factory));
 
   return context;
 }
 
 net::URLRequestContext*
 ProfileImplIOData::InitializeMediaRequestContext(
     net::URLRequestContext* original_context,
     const StoragePartitionDescriptor& partition_descriptor) const {
   // Copy most state from the original context.
   MediaRequestContext* context = new MediaRequestContext();
@@ skipping 19 matching lines @@
 
   // Use a separate HTTP disk cache for isolated apps.
   scoped_ptr<net::HttpCache::BackendFactory> media_backend(
       new net::HttpCache::DefaultBackend(
           net::MEDIA_CACHE,
           ChooseCacheBackendType(),
           cache_path,
           cache_max_size,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)));
   scoped_ptr<net::HttpCache> media_http_cache =
-      CreateHttpFactory(http_network_session_.get(), media_backend.Pass());
+      CreateHttpFactory(http_network_session_.get(), std::move(media_backend));
 
   // Transfer ownership of the cache to MediaRequestContext.
-  context->SetHttpTransactionFactory(media_http_cache.Pass());
+  context->SetHttpTransactionFactory(std::move(media_http_cache));
 
   // Note that we do not create a new URLRequestJobFactory because
   // the media context should behave exactly like its parent context
   // in all respects except for cache behavior on media subresources.
   // The CopyFrom() step above means that our media context will use
   // the same URLRequestJobFactory instance that our parent context does.
 
   return context;
 }
 
 net::URLRequestContext*
 ProfileImplIOData::AcquireMediaRequestContext() const {
   DCHECK(media_request_context_);
   return media_request_context_.get();
 }
 
 net::URLRequestContext* ProfileImplIOData::AcquireIsolatedAppRequestContext(
     net::URLRequestContext* main_context,
     const StoragePartitionDescriptor& partition_descriptor,
     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
         protocol_handler_interceptor,
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector request_interceptors) const {
   // We create per-app contexts on demand, unlike the others above.
-  net::URLRequestContext* app_request_context =
-      InitializeAppRequestContext(main_context,
-                                  partition_descriptor,
-                                  protocol_handler_interceptor.Pass(),
-                                  protocol_handlers,
-                                  request_interceptors.Pass());
+  net::URLRequestContext* app_request_context = InitializeAppRequestContext(
+      main_context, partition_descriptor,
+      std::move(protocol_handler_interceptor), protocol_handlers,
+      std::move(request_interceptors));
   DCHECK(app_request_context);
   return app_request_context;
 }
 
 net::URLRequestContext*
 ProfileImplIOData::AcquireIsolatedMediaRequestContext(
     net::URLRequestContext* app_context,
     const StoragePartitionDescriptor& partition_descriptor) const {
   // We create per-app media contexts on demand, unlike the others above.
   net::URLRequestContext* media_request_context =
       InitializeMediaRequestContext(app_context, partition_descriptor);
   DCHECK(media_request_context);
   return media_request_context;
 }
 
 void ProfileImplIOData::ClearNetworkingHistorySinceOnIOThread(
     base::Time time,
     const base::Closure& completion) {
   DCHECK_CURRENTLY_ON(BrowserThread::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);
 }