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

chromecast/browser/url_request_context_factory.cc

 // Copyright 2014 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 "chromecast/browser/url_request_context_factory.h"
 
+#include <utility>
+
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/threading/worker_pool.h"
 #include "chromecast/base/chromecast_switches.h"
 #include "chromecast/browser/cast_http_user_agent_settings.h"
 #include "chromecast/browser/cast_network_delegate.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
@@ skipping 77 matching lines @@
 class URLRequestContextFactory::MainURLRequestContextGetter
     : public net::URLRequestContextGetter {
  public:
   MainURLRequestContextGetter(
       URLRequestContextFactory* factory,
       content::BrowserContext* browser_context,
       content::ProtocolHandlerMap* protocol_handlers,
       content::URLRequestInterceptorScopedVector request_interceptors)
       : browser_context_(browser_context),
         factory_(factory),
-        request_interceptors_(request_interceptors.Pass()) {
+        request_interceptors_(std::move(request_interceptors)) {
     std::swap(protocol_handlers_, *protocol_handlers);
   }
 
   net::URLRequestContext* GetURLRequestContext() override {
     if (!request_context_) {
       request_context_.reset(factory_->CreateMainRequestContext(
-          browser_context_, &protocol_handlers_, request_interceptors_.Pass()));
+          browser_context_, &protocol_handlers_,
+          std::move(request_interceptors_)));
       protocol_handlers_.clear();
     }
     return request_context_.get();
   }
 
   scoped_refptr<base::SingleThreadTaskRunner>
       GetNetworkTaskRunner() const override {
     return content::BrowserThread::GetMessageLoopProxyForThread(
         content::BrowserThread::IO);
   }
@@ skipping 38 matching lines @@
 
   net_log_ = net_log;
 }
 
 net::URLRequestContextGetter* URLRequestContextFactory::CreateMainGetter(
     content::BrowserContext* browser_context,
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector request_interceptors) {
   DCHECK(!main_getter_.get())
       << "Main URLRequestContextGetter already initialized";
-  main_getter_ = new MainURLRequestContextGetter(this,
-                                                 browser_context,
-                                                 protocol_handlers,
-                                                 request_interceptors.Pass());
+  main_getter_ =
+      new MainURLRequestContextGetter(this, browser_context, protocol_handlers,
+                                      std::move(request_interceptors));
   return main_getter_.get();
 }
 
 net::URLRequestContextGetter* URLRequestContextFactory::GetMainGetter() {
   CHECK(main_getter_.get());
   return main_getter_.get();
 }
 
 net::URLRequestContextGetter* URLRequestContextFactory::GetSystemGetter() {
   if (!system_getter_.get()) {
@@ skipping 22 matching lines @@
   transport_security_state_.reset(new net::TransportSecurityState());
   http_auth_handler_factory_ =
       net::HttpAuthHandlerFactory::CreateDefault(host_resolver_.get());
 
   // TODO(lcwu): http://crbug.com/392352. For performance reasons,
   // a persistent (on-disk) HttpServerProperties might be desirable
   // in the future.
   http_server_properties_.reset(new net::HttpServerPropertiesImpl);
 
   proxy_service_ = net::ProxyService::CreateUsingSystemProxyResolver(
-      proxy_config_service_.Pass(), 0, NULL);
+      std::move(proxy_config_service_), 0, NULL);
   system_dependencies_initialized_ = true;
 }
 
 void URLRequestContextFactory::InitializeMainContextDependencies(
     net::HttpTransactionFactory* transaction_factory,
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector request_interceptors) {
   if (main_dependencies_initialized_)
     return;
 
@@ skipping 19 matching lines @@
     set_protocol = job_factory->SetProtocolHandler(
         url::kFileScheme,
         make_scoped_ptr(new net::FileProtocolHandler(
             content::BrowserThread::GetBlockingPool()
                 ->GetTaskRunnerWithShutdownBehavior(
                     base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
     DCHECK(set_protocol);
   }
 
   // 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();
 
   main_job_factory_.reset(top_job_factory.release());
 
   main_dependencies_initialized_ = true;
 }
 
 void URLRequestContextFactory::InitializeMediaContextDependencies(
     net::HttpTransactionFactory* transaction_factory) {
@@ skipping 87 matching lines @@
   base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kIgnoreCertificateErrors)) {
     ignore_certificate_errors = true;
   }
   net::HttpNetworkSession::Params network_session_params;
   PopulateNetworkSessionParams(ignore_certificate_errors,
                                &network_session_params);
   InitializeMainContextDependencies(
       new net::HttpNetworkLayer(
           new net::HttpNetworkSession(network_session_params)),
-      protocol_handlers,
-      request_interceptors.Pass());
+      protocol_handlers, std::move(request_interceptors));
 
   content::CookieStoreConfig cookie_config(
       browser_context->GetPath().Append(kCookieStoreFile),
       content::CookieStoreConfig::PERSISTANT_SESSION_COOKIES,
       NULL, NULL);
   cookie_config.background_task_runner =
       scoped_refptr<base::SequencedTaskRunner>();
   scoped_refptr<net::CookieStore> cookie_store =
       content::CreateCookieStore(cookie_config);
 
@@ skipping 22 matching lines @@
 
 void URLRequestContextFactory::InitializeNetworkDelegates() {
   app_network_delegate_->Initialize(false);
   LOG(INFO) << "Initialized app network delegate.";
   system_network_delegate_->Initialize(false);
   LOG(INFO) << "Initialized system network delegate.";
 }
 
 }  // namespace shell
 }  // namespace chromecast