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

android_webview/browser/net/aw_url_request_context_getter.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 "android_webview/browser/net/aw_url_request_context_getter.h"
 
+#include <utility>
 #include <vector>
 
 #include "android_webview/browser/aw_browser_context.h"
 #include "android_webview/browser/aw_content_browser_client.h"
 #include "android_webview/browser/net/aw_http_user_agent_settings.h"
 #include "android_webview/browser/net/aw_network_delegate.h"
 #include "android_webview/browser/net/aw_request_interceptor.h"
 #include "android_webview/browser/net/aw_url_request_job_factory.h"
 #include "android_webview/browser/net/init_native_callback.h"
 #include "android_webview/common/aw_content_client.h"
@@ skipping 119 matching lines @@
   // factories. This for WebViewClassic compatibility where it was not
   // possible to intercept resource loads to resolvable content:// and
   // file:// URIs.
   // This logical dependency is also the reason why the Content
   // URLRequestInterceptor has to be added as an interceptor rather than as a
   // ProtocolHandler.
   request_interceptors.push_back(new AwRequestInterceptor());
 
   // The chain of responsibility will execute the handlers in reverse to the
   // order in which the elements of the chain are created.
-  scoped_ptr<net::URLRequestJobFactory> job_factory(aw_job_factory.Pass());
+  scoped_ptr<net::URLRequestJobFactory> job_factory(std::move(aw_job_factory));
   for (content::URLRequestInterceptorScopedVector::reverse_iterator i =
            request_interceptors.rbegin();
        i != request_interceptors.rend();
        ++i) {
     job_factory.reset(new net::URLRequestInterceptingJobFactory(
-        job_factory.Pass(), make_scoped_ptr(*i)));
+        std::move(job_factory), make_scoped_ptr(*i)));
   }
   request_interceptors.weak_clear();
 
-  return job_factory.Pass();
+  return job_factory;
 }
 
 }  // namespace
 
 AwURLRequestContextGetter::AwURLRequestContextGetter(
     const base::FilePath& cache_path,
     net::CookieStore* cookie_store,
     scoped_ptr<net::ProxyConfigService> config_service,
     PrefService* user_pref_service)
     : cache_path_(cache_path),
       net_log_(new net::NetLog()),
-      proxy_config_service_(config_service.Pass()),
+      proxy_config_service_(std::move(config_service)),
       cookie_store_(cookie_store),
       http_user_agent_settings_(new AwHttpUserAgentSettings()) {
   // CreateSystemProxyConfigService for Android must be called on main thread.
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   scoped_refptr<base::SingleThreadTaskRunner> io_thread_proxy =
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
 
   auth_server_whitelist_.Init(
       prefs::kAuthServerWhitelist, user_pref_service,
@@ skipping 16 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!url_request_context_);
 
   net::URLRequestContextBuilder builder;
   scoped_ptr<AwNetworkDelegate> aw_network_delegate(new AwNetworkDelegate());
 
   AwBrowserContext* browser_context = AwBrowserContext::GetDefault();
   DCHECK(browser_context);
 
   builder.set_network_delegate(
-      browser_context->GetDataReductionProxyIOData()
-          ->CreateNetworkDelegate(
-              aw_network_delegate.Pass(),
-              false /* No UMA is produced to track bypasses. */)
-          .Pass());
+      browser_context->GetDataReductionProxyIOData()->CreateNetworkDelegate(
+          std::move(aw_network_delegate),
+          false /* No UMA is produced to track bypasses. */));
 #if !defined(DISABLE_FTP_SUPPORT)
   builder.set_ftp_enabled(false);  // Android WebView does not support ftp yet.
 #endif
   DCHECK(proxy_config_service_.get());
   // Android provides a local HTTP proxy that handles all the proxying.
   // Create the proxy without a resolver since we rely on this local HTTP proxy.
   // TODO(sgurun) is this behavior guaranteed through SDK?
   builder.set_proxy_service(net::ProxyService::CreateWithoutProxyResolver(
-      proxy_config_service_.Pass(), net_log_.get()));
+      std::move(proxy_config_service_), net_log_.get()));
   builder.set_net_log(net_log_.get());
   builder.SetCookieAndChannelIdStores(cookie_store_, NULL);
 
   net::URLRequestContextBuilder::HttpCacheParams cache_params;
   cache_params.type =
       net::URLRequestContextBuilder::HttpCacheParams::DISK_SIMPLE;
   cache_params.max_size = 20 * 1024 * 1024;  // 20M
   cache_params.path = cache_path_;
   builder.EnableHttpCache(cache_params);
   builder.SetFileTaskRunner(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
 
   net::URLRequestContextBuilder::HttpNetworkSessionParams
       network_session_params;
   ApplyCmdlineOverridesToNetworkSessionParams(&network_session_params);
   builder.set_http_network_session_params(network_session_params);
   builder.SetSpdyAndQuicEnabled(true, false);
 
   scoped_ptr<net::MappedHostResolver> host_resolver(new net::MappedHostResolver(
       net::HostResolver::CreateDefaultResolver(nullptr)));
   ApplyCmdlineOverridesToHostResolver(host_resolver.get());
   builder.SetHttpAuthHandlerFactory(
-      CreateAuthHandlerFactory(host_resolver.get()).Pass());
-  builder.set_host_resolver(host_resolver.Pass());
+      CreateAuthHandlerFactory(host_resolver.get()));
+  builder.set_host_resolver(std::move(host_resolver));
 
-  url_request_context_ = builder.Build().Pass();
+  url_request_context_ = builder.Build();
 
-  job_factory_ = CreateJobFactory(&protocol_handlers_,
-                                  request_interceptors_.Pass());
+  job_factory_ =
+      CreateJobFactory(&protocol_handlers_, std::move(request_interceptors_));
   job_factory_.reset(new net::URLRequestInterceptingJobFactory(
-      job_factory_.Pass(),
+      std::move(job_factory_),
       browser_context->GetDataReductionProxyIOData()->CreateInterceptor()));
   url_request_context_->set_job_factory(job_factory_.get());
   url_request_context_->set_http_user_agent_settings(
       http_user_agent_settings_.get());
 }
 
 net::URLRequestContext* AwURLRequestContextGetter::GetURLRequestContext() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!url_request_context_)
     InitializeURLRequestContext();
@@ skipping 44 matching lines @@
   http_auth_preferences_->set_server_whitelist(
       auth_server_whitelist_.GetValue());
 }
 
 void AwURLRequestContextGetter::UpdateAndroidAuthNegotiateAccountType() {
   http_auth_preferences_->set_auth_android_negotiate_account_type(
       auth_android_negotiate_account_type_.GetValue());
 }
 
 }  // namespace android_webview