Make URLRequestContextBuilder use base/task_scheduler/

net/url_request/url_request_context_builder.h

 // 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.
 
 // This class is useful for building a simple URLRequestContext. Most creators
 // of new URLRequestContexts should use this helper class to construct it. Call
 // any configuration params, and when done, invoke Build() to construct the
 // URLRequestContext. This URLRequestContext will own all its own storage.
 //
 // URLRequestContextBuilder and its associated params classes are initially
 // populated with "sane" default values. Read through the comments to figure out
 // what these are.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_
 #define NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/task_scheduler/task_traits.h"
 #include "build/build_config.h"
 #include "net/base/net_export.h"
 #include "net/base/network_delegate.h"
 #include "net/base/proxy_delegate.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_network_session.h"
 #include "net/net_features.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_service.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/socket/next_proto.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/url_request/url_request_job_factory.h"
 
 namespace base {
 class SingleThreadTaskRunner;
+class SequencedTaskRunner;
+class TaskRunner;
 }
 
 namespace net {
 
 class CertVerifier;
 class ChannelIDService;
 class CookieStore;
 class CTVerifier;
 class HttpAuthHandlerFactory;
 class HttpServerProperties;
@@ skipping 263 matching lines @@
   // If |cookie_store| is not NULL and |channel_id_service| is NULL,
   // only ChannelIdService is disabled for this context.
   // Note that a persistent cookie store should not be used with an in-memory
   // channel id service, and one cookie store should not be shared between
   // multiple channel-id stores (or used both with and without a channel id
   // store).
   void SetCookieAndChannelIdStores(
       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, one will
-  // be created.
+  // 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);
 
   // Note that if SDCH is enabled without a policy object observing
   // the SDCH manager and handling at least Get-Dictionary events, the
   // result will be "Content-Encoding: sdch" advertisements, but no
   // dictionaries fetches and no specific dictionaries advertised.
   // SdchOwner in net/sdch/sdch_owner.h is a simple policy object.
   void set_sdch_enabled(bool enable) { sdch_enabled_ = enable; }
 
@@ skipping 11 matching lines @@
   // Lets subclasses override ProxyService creation, using a ProxyService that
   // uses the URLRequestContext itself to get PAC scripts. When this method is
   // invoked, the URLRequestContext is not yet ready to service requests.
   virtual std::unique_ptr<ProxyService> CreateProxyService(
       std::unique_ptr<ProxyConfigService> proxy_config_service,
       URLRequestContext* url_request_context,
       HostResolver* host_resolver,
       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.

[Randy Smith (Not in Mondays), 2017/06/21 12:56:26]

I also find myself wondering if names that captured more of the goals of these
routines for URLRequestContextBuilder (i.e. slightly higher level) might be
better.  I'll mention that now in case it sparks ideas in your mind, but feel
free to ignore the comment--if I still feel that way after I understand the
purposes better I'll make concrete suggestions.

[Randy Smith (Not in Mondays), 2017/06/21 12:56:26]

nit, suggestion: It bothers me a little that we're being specific about using a
file related thingy above (in the setter) but the naming of these methods
doesn't mention that it's for file operations.  WDYT about including "File" in
the names?

[mmenke, 2017/06/21 15:13:56]

I'm open to other ideas.  Largely I just wanted reusable methods to use either
the task schedule or passed in TaskRunner.  Each method is only used once
currently, but we'll need to at least add the CookieStore, and I think having
methods is less regression prone than inlinine the logic everywhere.

[mmenke, 2017/06/21 15:13:56]

Done.  I didn't do this in the first place mostly because I didn't like either
GetFile*TaskRunner as sounding awkward or Get*FileTaskRunner as interrupting
class names, and adding more works (ForFileIO or whatever) starts making these
method names absurdly long.

+  scoped_refptr<base::TaskRunner> GetTaskRunner(const base::TaskTraits& traits);
+  scoped_refptr<base::SequencedTaskRunner> GetSequencedTaskRunner(
+      const base::TaskTraits& traits);
+  scoped_refptr<base::SingleThreadTaskRunner> GetSingleThreadTaskRunner(
+      const base::TaskTraits& traits);
+
  private:
   const char* name_;
   bool enable_brotli_;
   NetworkQualityEstimator* network_quality_estimator_;
 
   std::string accept_language_;
   std::string user_agent_;
   // Include support for data:// requests.
   bool data_enabled_;
 #if !BUILDFLAG(DISABLE_FILE_SUPPORT)
   // Include support for file:// requests.
   bool file_enabled_;
 #endif
 #if !BUILDFLAG(DISABLE_FTP_SUPPORT)
   // Include support for ftp:// requests.
   bool ftp_enabled_;
 #endif
   bool http_cache_enabled_;
   bool throttling_enabled_;
   bool sdch_enabled_;
   bool cookie_store_set_by_client_;
 
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
+
   HttpCacheParams http_cache_params_;
   HttpNetworkSession::Params http_network_session_params_;
   base::FilePath transport_security_persister_path_;
   NetLog* net_log_;
   std::unique_ptr<HostResolver> host_resolver_;
   std::unique_ptr<ChannelIDService> channel_id_service_;
   std::unique_ptr<ProxyConfigService> proxy_config_service_;
   bool pac_quick_check_enabled_;
   ProxyService::SanitizeUrlPolicy pac_sanitize_url_policy_;
   std::unique_ptr<ProxyService> proxy_service_;
   scoped_refptr<net::SSLConfigService> ssl_config_service_;
   std::unique_ptr<NetworkDelegate> network_delegate_;
   std::unique_ptr<ProxyDelegate> proxy_delegate_;
   std::unique_ptr<CookieStore> cookie_store_;
   std::unique_ptr<HttpAuthHandlerFactory> http_auth_handler_factory_;
   std::unique_ptr<CertVerifier> cert_verifier_;
   std::unique_ptr<CTVerifier> ct_verifier_;
   std::unique_ptr<net::ReportingPolicy> reporting_policy_;
   std::vector<std::unique_ptr<URLRequestInterceptor>> url_request_interceptors_;
   std::unique_ptr<HttpServerProperties> http_server_properties_;
   std::map<std::string, std::unique_ptr<URLRequestJobFactory::ProtocolHandler>>
       protocol_handlers_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestContextBuilder);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_