Use TaskRunner passed in to URLRequestContextBuilder only for the cache

It used to be used for file URLs and TransportSecurityStatePersister as
well, but this CL moves those over to using the task scheduler. Can't
just always use that for the cache as well due to the cache needing a
SingleThreadTaskRunner, and getting one of those from the task scheduler
is a bit more resource intensive.

BUG=734199
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.android:android_cronet_tester

Review-Url: https://codereview.chromium.org/2977693003
Cr-Commit-Position: refs/heads/master@{#485919}

android_webview/browser/net/aw_url_request_context_getter.cc

@@ -254,7 +254,7 @@ void AwURLRequestContextGetter::InitializeURLRequestContext() {
   cache_params.max_size = 20 * 1024 * 1024;  // 20M
   cache_params.path = cache_path_;
   builder.EnableHttpCache(cache_params);
-  builder.SetFileTaskRunner(
+  builder.SetCacheThreadTaskRunner(
       BrowserThread::GetTaskRunnerForThread(BrowserThread::CACHE));
 
   net::HttpNetworkSession::Params network_session_params;

components/cronet/android/cronet_url_request_context_adapter.cc

@@ -659,7 +659,7 @@ void CronetURLRequestContextAdapter::InitializeOnNetworkThread(
     json_pref_store_ =
         new JsonPrefStore(filepath, GetFileThread()->task_runner(),
                           std::unique_ptr<PrefFilter>());
-    context_builder.SetFileTaskRunner(GetFileThread()->task_runner());
+    context_builder.SetCacheThreadTaskRunner(GetFileThread()->task_runner());
 
     // Register prefs and set up the PrefService.
     PrefServiceFactory factory;

headless/lib/browser/headless_url_request_context_getter.cc

@@ -29,8 +29,6 @@ HeadlessURLRequestContextGetter::HeadlessURLRequestContextGetter(
     net::NetLog* net_log,
     HeadlessBrowserContextImpl* headless_browser_context)
     : io_task_runner_(std::move(io_task_runner)),
-      file_task_runner_(base::CreateSingleThreadTaskRunnerWithTraits(
-          {base::MayBlock(), base::TaskPriority::BACKGROUND})),
       user_agent_(options->user_agent()),
       host_resolver_rules_(options->host_resolver_rules()),
       proxy_config_(options->proxy_config()),
@@ -70,7 +68,6 @@ HeadlessURLRequestContextGetter::GetURLRequestContext() {
     // TODO(skyostil): Make these configurable.
     builder.set_data_enabled(true);
     builder.set_file_enabled(true);
-    builder.SetFileTaskRunner(file_task_runner_);
     if (proxy_config_) {
       builder.set_proxy_service(net::ProxyService::CreateFixed(*proxy_config_));
     } else {

headless/lib/browser/headless_url_request_context_getter.h

@@ -53,9 +53,6 @@ class HeadlessURLRequestContextGetter : public net::URLRequestContextGetter {
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
-  // TODO(eseckler): This should become a SequencedTaskRunner once net:: APIs
-  // accept a SequencedTaskRunner, see https://crbug.com/735368.
-  scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
 
   // The |options| object given to the constructor is not guaranteed to outlive
   // this class, so we make copies of the parts we need to access on the IO

net/url_request/url_request_context_builder.cc

@@ -291,9 +291,9 @@ void URLRequestContextBuilder::SetCookieAndChannelIdStores(
   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(
@@ -383,7 +383,7 @@ std::unique_ptr<URLRequestContext> URLRequestContextBuilder::Build() {
     // 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}));
 
@@ -459,16 +459,19 @@ std::unique_ptr<URLRequestContext> URLRequestContextBuilder::Build() {
   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);
@@ -499,7 +502,7 @@ std::unique_ptr<URLRequestContext> URLRequestContextBuilder::Build() {
   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})));
   }
@@ -545,27 +548,4 @@ std::unique_ptr<ProxyService> URLRequestContextBuilder::CreateProxyService(
       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

net/url_request/url_request_context_builder.h

@@ -44,8 +44,6 @@
 
 namespace base {
 class SingleThreadTaskRunner;
-class SequencedTaskRunner;
-class TaskRunner;
 }
 
 namespace net {
@@ -282,10 +280,12 @@ class NET_EXPORT URLRequestContextBuilder {
       std::unique_ptr<CookieStore> cookie_store,
       std::unique_ptr<ChannelIDService> channel_id_service);
 
-  // Sets the task runner used to perform file operations. If not set,
-  // TaskSchedulers will be used instead.
-  void SetFileTaskRunner(
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
+  // Sets the SingleThreadTaskRunner used to perform cache operations. If not
+  // set, one will be created via a TaskScheduler instead. Other file tasks will
+  // use the task scheduler, but the cache needs a SingleThreadTaskRunner, so
+  // best to keep that configurable by the consumer.
+  void SetCacheThreadTaskRunner(
+      scoped_refptr<base::SingleThreadTaskRunner> cache_thread_task_runner);
 
   // Note that if SDCH is enabled without a policy object observing
   // the SDCH manager and handling at least Get-Dictionary events, the
@@ -315,16 +315,6 @@ class NET_EXPORT URLRequestContextBuilder {
       NetworkDelegate* network_delegate,
       NetLog* net_log);
 
-  // Returns a TaskRunner with the specified traits. If |file_task_runner_| is
-  // non-NULL, uses that. Otherwise, uses base/task_scheduler/ and the specified
-  // traits.
-  scoped_refptr<base::TaskRunner> GetFileTaskRunner(
-      const base::TaskTraits& traits);
-  scoped_refptr<base::SequencedTaskRunner> GetFileSequencedTaskRunner(
-      const base::TaskTraits& traits);
-  scoped_refptr<base::SingleThreadTaskRunner> GetFileSingleThreadTaskRunner(
-      const base::TaskTraits& traits);
-
  private:
   const char* name_;
   bool enable_brotli_;
@@ -347,7 +337,7 @@ class NET_EXPORT URLRequestContextBuilder {
   bool sdch_enabled_;
   bool cookie_store_set_by_client_;
 
-  scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> cache_thread_task_runner_;
   HttpCacheParams http_cache_params_;
   HttpNetworkSession::Params http_network_session_params_;
   base::FilePath transport_security_persister_path_;

remoting/base/url_request_context_getter.cc

@@ -25,7 +25,6 @@ URLRequestContextGetter::URLRequestContextGetter(
 net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
   if (!url_request_context_.get()) {
     net::URLRequestContextBuilder builder;
-    builder.SetFileTaskRunner(file_task_runner_);
     net_log_.reset(new VlogNetLog());
     builder.set_net_log(net_log_.get());
     builder.DisableHttpCache();

remoting/base/url_request_context_getter.h

@@ -23,6 +23,7 @@ namespace remoting {
 
 class URLRequestContextGetter : public net::URLRequestContextGetter {
  public:
+  // TODO(mmenke): Remove |file_task_runner|, as it's no longer used.
   URLRequestContextGetter(
       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> file_task_runner);