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

chrome/browser/profiles/profile_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_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 338 matching lines @@
   }
 }
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(USE_NSS_CERTS)
 void InitializeAndPassKeygenHandler(
     scoped_ptr<net::KeygenHandler> keygen_handler,
     const base::Callback<void(scoped_ptr<net::KeygenHandler>)>& callback,
     scoped_ptr<ChromeNSSCryptoModuleDelegate> delegate) {
   if (delegate)
-    keygen_handler->set_crypto_module_delegate(delegate.Pass());
-  callback.Run(keygen_handler.Pass());
+    keygen_handler->set_crypto_module_delegate(std::move(delegate));
+  callback.Run(std::move(keygen_handler));
 }
 #endif  // defined(USE_NSS_CERTS)
 
 // For safe shutdown, must be called before the ProfileIOData is destroyed.
 void NotifyContextGettersOfShutdownOnIO(
     scoped_ptr<ProfileIOData::ChromeURLRequestContextGetterVector> getters) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ProfileIOData::ChromeURLRequestContextGetterVector::iterator iter;
   for (auto& chrome_context_getter : *getters)
     chrome_context_getter->NotifyContextShuttingDown();
@@ skipping 172 matching lines @@
   // are associated with each ResourceContext because we might post this
   // object to the IO thread after this function.
   BrowserContext::EnsureResourceContextInitialized(profile);
 }
 
 ProfileIOData::MediaRequestContext::MediaRequestContext() {
 }
 
 void ProfileIOData::MediaRequestContext::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());
 }
 
 ProfileIOData::MediaRequestContext::~MediaRequestContext() {
   AssertNoURLRequests();
 }
 
 ProfileIOData::AppRequestContext::AppRequestContext() {
 }
 
 void ProfileIOData::AppRequestContext::SetCookieStore(
     net::CookieStore* cookie_store) {
   cookie_store_ = cookie_store;
   set_cookie_store(cookie_store);
 }
 
 void ProfileIOData::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 ProfileIOData::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());
 }
 
 ProfileIOData::AppRequestContext::~AppRequestContext() {
   AssertNoURLRequests();
 }
 
 ProfileIOData::ProfileParams::ProfileParams()
     : io_thread(NULL),
 #if defined(OS_CHROMEOS)
@@ skipping 197 matching lines @@
     const StoragePartitionDescriptor& partition_descriptor,
     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
         protocol_handler_interceptor,
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector request_interceptors) const {
   DCHECK(initialized_);
   net::URLRequestContext* context = NULL;
   if (ContainsKey(app_request_context_map_, partition_descriptor)) {
     context = app_request_context_map_[partition_descriptor];
   } else {
-    context =
-        AcquireIsolatedAppRequestContext(main_context,
-                                         partition_descriptor,
-                                         protocol_handler_interceptor.Pass(),
-                                         protocol_handlers,
-                                         request_interceptors.Pass());
+    context = AcquireIsolatedAppRequestContext(
+        main_context, partition_descriptor,
+        std::move(protocol_handler_interceptor), protocol_handlers,
+        std::move(request_interceptors));
     app_request_context_map_[partition_descriptor] = context;
   }
   DCHECK(context);
   return context;
 }
 
 net::URLRequestContext* ProfileIOData::GetIsolatedMediaRequestContext(
     net::URLRequestContext* app_context,
     const StoragePartitionDescriptor& partition_descriptor) const {
   DCHECK(initialized_);
@@ skipping 74 matching lines @@
 }
 
 bool ProfileIOData::IsDataReductionProxyEnabled() const {
   return data_reduction_proxy_io_data() &&
       data_reduction_proxy_io_data()->IsEnabled();
 }
 
 void ProfileIOData::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>
 ProfileIOData::http_server_properties() const {
   return http_server_properties_->GetWeakPtr();
 }
 
 void ProfileIOData::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);
 }
 
 ProfileIOData::ResourceContext::ResourceContext(ProfileIOData* io_data)
     : io_data_(io_data),
       host_resolver_(NULL),
       request_context_(NULL) {
   DCHECK(io_data);
 }
 
 ProfileIOData::ResourceContext::~ResourceContext() {}
@@ skipping 123 matching lines @@
   network_delegate->set_force_youtube_safety_mode(&force_youtube_safety_mode_);
   network_delegate->set_data_use_aggregator(
       io_thread_globals->data_use_aggregator.get(), IsOffTheRecord());
 
   // NOTE: Proxy service uses the default io thread network delegate, not the
   // delegate just created.
   proxy_service_ = ProxyServiceFactory::CreateProxyService(
       io_thread->net_log(),
       io_thread_globals->proxy_script_fetcher_context.get(),
       io_thread_globals->system_network_delegate.get(),
-      profile_params_->proxy_config_service.Pass(), command_line,
+      std::move(profile_params_->proxy_config_service), command_line,
       quick_check_enabled_.GetValue());
   transport_security_state_.reset(new net::TransportSecurityState());
   base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   transport_security_persister_.reset(
       new net::TransportSecurityPersister(
           transport_security_state_.get(),
           profile_params_->path,
           pool->GetSequencedTaskRunnerWithShutdownBehavior(
               pool->GetSequenceToken(),
               base::SequencedWorkerPool::BLOCK_SHUTDOWN),
@@ skipping 59 matching lines @@
   // Install the New Tab Page Interceptor.
   if (profile_params_->new_tab_page_interceptor.get()) {
     request_interceptors.push_back(
         profile_params_->new_tab_page_interceptor.release());
   }
 
   scoped_ptr<net::MultiLogCTVerifier> ct_verifier(
       new net::MultiLogCTVerifier());
   ct_verifier->AddLogs(io_thread_globals->ct_logs);
   main_request_context_->set_cert_transparency_verifier(ct_verifier.get());
-  cert_transparency_verifier_ = ct_verifier.Pass();
+  cert_transparency_verifier_ = std::move(ct_verifier);
 
-  InitializeInternal(
-      network_delegate.Pass(), profile_params_.get(),
-      protocol_handlers, request_interceptors.Pass());
+  InitializeInternal(std::move(network_delegate), profile_params_.get(),
+                     protocol_handlers, std::move(request_interceptors));
 
   profile_params_.reset();
   initialized_ = true;
 }
 
 void ProfileIOData::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 59 matching lines @@
   job_factory->SetProtocolHandler(
       url::kFtpScheme,
       make_scoped_ptr(new net::FtpProtocolHandler(ftp_transaction_factory)));
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 #if defined(DEBUG_DEVTOOLS)
   request_interceptors.push_back(new DebugDevToolsInterceptor);
 #endif
 
   // 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 (content::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();
 
   if (protocol_handler_interceptor) {
-    protocol_handler_interceptor->Chain(top_job_factory.Pass());
-    return protocol_handler_interceptor.Pass();
+    protocol_handler_interceptor->Chain(std::move(top_job_factory));
+    return std::move(protocol_handler_interceptor);
   } else {
-    return top_job_factory.Pass();
+    return top_job_factory;
   }
 }
 
 void ProfileIOData::ShutdownOnUIThread(
     scoped_ptr<ChromeURLRequestContextGetterVector> context_getters) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   google_services_user_account_id_.Destroy();
   enable_referrers_.Destroy();
   enable_do_not_track_.Destroy();
@@ skipping 59 matching lines @@
   return scoped_ptr<net::HttpNetworkSession>(
       new net::HttpNetworkSession(params));
 }
 
 scoped_ptr<net::HttpCache> ProfileIOData::CreateMainHttpFactory(
     net::HttpNetworkSession* session,
     scoped_ptr<net::HttpCache::BackendFactory> main_backend) const {
   return make_scoped_ptr(new net::HttpCache(
       make_scoped_ptr(new DevToolsNetworkTransactionFactory(
           network_controller_handle_.GetController(), session)),
-      main_backend.Pass(), true /* set_up_quic_server_info */));
+      std::move(main_backend), true /* set_up_quic_server_info */));
 }
 
 scoped_ptr<net::HttpCache> ProfileIOData::CreateHttpFactory(
     net::HttpNetworkSession* shared_session,
     scoped_ptr<net::HttpCache::BackendFactory> backend) const {
   return make_scoped_ptr(new net::HttpCache(
       make_scoped_ptr(new DevToolsNetworkTransactionFactory(
           network_controller_handle_.GetController(), shared_session)),
-      backend.Pass(), true /* set_up_quic_server_info */));
+      std::move(backend), true /* set_up_quic_server_info */));
 }
 
 void ProfileIOData::SetCookieSettingsForTesting(
     content_settings::CookieSettings* cookie_settings) {
   DCHECK(!cookie_settings_.get());
   cookie_settings_ = cookie_settings;
 }