Use TaskRunner passed in to URLRequestContextBuilder only for the cache

net/url_request/url_request_context_builder.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 "net/url_request/url_request_context_builder.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 273 matching lines @@
 void URLRequestContextBuilder::SetCookieAndChannelIdStores(
     std::unique_ptr<CookieStore> cookie_store,
     std::unique_ptr<ChannelIDService> channel_id_service) {
   cookie_store_set_by_client_ = true;
   // If |cookie_store| is NULL, |channel_id_service| must be NULL too.
   DCHECK(cookie_store || !channel_id_service);
   cookie_store_ = std::move(cookie_store);
   channel_id_service_ = std::move(channel_id_service);
 }
 
-void URLRequestContextBuilder::SetFileTaskRunner(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
-  file_task_runner_ = task_runner;
+void URLRequestContextBuilder::SetCacheThreadTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> cache_thread_task_runner) {
+  cache_thread_task_runner_ = std::move(cache_thread_task_runner);
 }
 
 void URLRequestContextBuilder::SetProtocolHandler(
     const std::string& scheme,
     std::unique_ptr<URLRequestJobFactory::ProtocolHandler> protocol_handler) {
   DCHECK(protocol_handler);
   protocol_handlers_[scheme] = std::move(protocol_handler);
 }
 
 void URLRequestContextBuilder::SetHttpAuthHandlerFactory(
@@ skipping 69 matching lines @@
         std::unique_ptr<net::SdchManager>(new SdchManager()));
   }
 
   storage->set_transport_security_state(
       base::MakeUnique<TransportSecurityState>());
   if (!transport_security_persister_path_.empty()) {
     // Use a low priority because saving this should not block anything
     // user-visible. Block shutdown to ensure it does get persisted to disk,
     // since it contains security-relevant information.
     scoped_refptr<base::SequencedTaskRunner> task_runner(
-        GetFileSequencedTaskRunner(
+        base::CreateSequencedTaskRunnerWithTraits(
             {base::MayBlock(), base::TaskPriority::BACKGROUND,
              base::TaskShutdownBehavior::BLOCK_SHUTDOWN}));
 
     context->set_transport_security_persister(
         base::WrapUnique<TransportSecurityPersister>(
             new TransportSecurityPersister(context->transport_security_state(),
                                            transport_security_persister_path_,
                                            task_runner, false)));
   }
 
@@ skipping 55 matching lines @@
     storage->set_proxy_delegate(std::move(proxy_delegate_));
   }
 
   storage->set_http_network_session(base::MakeUnique<HttpNetworkSession>(
       http_network_session_params_, network_session_context));
 
   std::unique_ptr<HttpTransactionFactory> http_transaction_factory;
   if (http_cache_enabled_) {
     std::unique_ptr<HttpCache::BackendFactory> http_cache_backend;
     if (http_cache_params_.type != HttpCacheParams::IN_MEMORY) {
+      if (!cache_thread_task_runner_) {
+        cache_thread_task_runner_ =
+            base::CreateSingleThreadTaskRunnerWithTraits(
+                {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
+                 base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
+      }
       BackendType backend_type =
           http_cache_params_.type == HttpCacheParams::DISK
               ? CACHE_BACKEND_DEFAULT
               : CACHE_BACKEND_SIMPLE;
       http_cache_backend.reset(new HttpCache::DefaultBackend(
           DISK_CACHE, backend_type, http_cache_params_.path,
-          http_cache_params_.max_size,
-          GetFileSingleThreadTaskRunner(
-              {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
-               base::TaskShutdownBehavior::BLOCK_SHUTDOWN})));
+          http_cache_params_.max_size, cache_thread_task_runner_));
     } else {
       http_cache_backend =
           HttpCache::DefaultBackend::InMemory(http_cache_params_.max_size);
     }
 
     http_transaction_factory.reset(new HttpCache(
         storage->http_network_session(), std::move(http_cache_backend), true));
   } else {
     http_transaction_factory.reset(
         new HttpNetworkLayer(storage->http_network_session()));
@@ skipping 10 matching lines @@
   protocol_handlers_.clear();
 
   if (data_enabled_)
     job_factory->SetProtocolHandler(url::kDataScheme,
                                     base::WrapUnique(new DataProtocolHandler));
 
 #if !BUILDFLAG(DISABLE_FILE_SUPPORT)
   if (file_enabled_) {
     job_factory->SetProtocolHandler(
         url::kFileScheme,
-        base::MakeUnique<FileProtocolHandler>(GetFileTaskRunner(
+        base::MakeUnique<FileProtocolHandler>(base::CreateTaskRunnerWithTraits(
             {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
              base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})));
   }
 #endif  // !BUILDFLAG(DISABLE_FILE_SUPPORT)
 
 #if !BUILDFLAG(DISABLE_FTP_SUPPORT)
   if (ftp_enabled_) {
     job_factory->SetProtocolHandler(
         url::kFtpScheme, FtpProtocolHandler::Create(context->host_resolver()));
   }
@@ skipping 25 matching lines @@
 std::unique_ptr<ProxyService> URLRequestContextBuilder::CreateProxyService(
     std::unique_ptr<ProxyConfigService> proxy_config_service,
     URLRequestContext* url_request_context,
     HostResolver* host_resolver,
     NetworkDelegate* network_delegate,
     NetLog* net_log) {
   return ProxyService::CreateUsingSystemProxyResolver(
       std::move(proxy_config_service), net_log);
 }
 
-scoped_refptr<base::TaskRunner> URLRequestContextBuilder::GetFileTaskRunner(
-    const base::TaskTraits& traits) {
-  if (file_task_runner_)
-    return file_task_runner_;
-  return base::CreateTaskRunnerWithTraits(traits);
-}
-
-scoped_refptr<base::SequencedTaskRunner>
-URLRequestContextBuilder::GetFileSequencedTaskRunner(
-    const base::TaskTraits& traits) {
-  if (file_task_runner_)
-    return file_task_runner_;
-  return base::CreateSequencedTaskRunnerWithTraits(traits);
-}
-
-scoped_refptr<base::SingleThreadTaskRunner>
-URLRequestContextBuilder::GetFileSingleThreadTaskRunner(
-    const base::TaskTraits& traits) {
-  if (file_task_runner_)
-    return file_task_runner_;
-  return base::CreateSingleThreadTaskRunnerWithTraits(traits);
-}
-
 }  // namespace net