chrome/browser/io_thread.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_IO_THREAD_H_
   6 #define CHROME_BROWSER_IO_THREAD_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/prefs/pref_member.h"
  17 #include "base/time/time.h"
  18 #include "chrome/browser/net/chrome_network_delegate.h"
  19 #include "chrome/browser/net/ssl_config_service_manager.h"
  20 #include "content/public/browser/browser_thread.h"
  21 #include "content/public/browser/browser_thread_delegate.h"
  22 #include "net/base/network_change_notifier.h"
  23 #include "net/http/http_network_session.h"
  24 #include "net/socket/next_proto.h"
  25
  26 class ChromeNetLog;
  27 class PrefProxyConfigTracker;
  28 class PrefService;
  29 class PrefRegistrySimple;
  30 class SystemURLRequestContextGetter;
  31
  32 namespace base {
  33 class CommandLine;
  34 }
  35
  36 namespace chrome_browser_net {
  37 class DnsProbeService;
  38 }
  39
  40 #if defined(SPDY_PROXY_AUTH_ORIGIN)
  41 namespace data_reduction_proxy {
  42 class DataReductionProxyAuthRequestHandler;
  43 class DataReductionProxyDelegate;
  44 class DataReductionProxyParams;
  45 }
  46 #endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
  47
  48 namespace extensions {
  49 class EventRouterForwarder;
  50 }
  51
  52 namespace net {
  53 class CertVerifier;
  54 class ChannelIDService;
  55 class CookieStore;
  56 class CTVerifier;
  57 class FtpTransactionFactory;
  58 class HostMappingRules;
  59 class HostResolver;
  60 class HttpAuthHandlerFactory;
  61 class HttpServerProperties;
  62 class HttpTransactionFactory;
  63 class HttpUserAgentSettings;
  64 class NetworkDelegate;
  65 class ProxyConfigService;
  66 class ProxyService;
  67 class SSLConfigService;
  68 class TransportSecurityState;
  69 class URLRequestContext;
  70 class URLRequestContextGetter;
  71 class URLRequestJobFactory;
  72 class URLRequestThrottlerManager;
  73 class URLSecurityManager;
  74 }  // namespace net
  75
  76 namespace policy {
  77 class PolicyService;
  78 }  // namespace policy
  79
  80 namespace test {
  81 class IOThreadPeer;
  82 }  // namespace test
  83
  84 // Contains state associated with, initialized and cleaned up on, and
  85 // primarily used on, the IO thread.
  86 //
  87 // If you are looking to interact with the IO thread (e.g. post tasks
  88 // to it or check if it is the current thread), see
  89 // content::BrowserThread.
  90 class IOThread : public content::BrowserThreadDelegate {
  91  public:
  92   struct Globals {
  93     template <typename T>
  94     class Optional {
  95      public:
  96       Optional() : set_(false) {}
  97
  98       void set(T value) {
  99         set_ = true;
 100         value_ = value;
 101       }
 102       void CopyToIfSet(T* value) const {
 103         if (set_) {
 104           *value = value_;
 105         }
 106       }
 107
 108      private:
 109       bool set_;
 110       T value_;
 111     };
 112
 113     class SystemRequestContextLeakChecker {
 114      public:
 115       explicit SystemRequestContextLeakChecker(Globals* globals);
 116       ~SystemRequestContextLeakChecker();
 117
 118      private:
 119       Globals* const globals_;
 120     };
 121
 122     Globals();
 123     ~Globals();
 124
 125     // The "system" NetworkDelegate, used for Profile-agnostic network events.
 126     scoped_ptr<net::NetworkDelegate> system_network_delegate;
 127     scoped_ptr<net::HostResolver> host_resolver;
 128     scoped_ptr<net::CertVerifier> cert_verifier;
 129     // The ChannelIDService must outlive the HttpTransactionFactory.
 130     scoped_ptr<net::ChannelIDService> system_channel_id_service;
 131     // This TransportSecurityState doesn't load or save any state. It's only
 132     // used to enforce pinning for system requests and will only use built-in
 133     // pins.
 134     scoped_ptr<net::TransportSecurityState> transport_security_state;
 135     scoped_ptr<net::CTVerifier> cert_transparency_verifier;
 136     scoped_refptr<net::SSLConfigService> ssl_config_service;
 137     scoped_ptr<net::HttpAuthHandlerFactory> http_auth_handler_factory;
 138     scoped_ptr<net::HttpServerProperties> http_server_properties;
 139     scoped_ptr<net::ProxyService> proxy_script_fetcher_proxy_service;
 140     scoped_ptr<net::HttpTransactionFactory>
 141         proxy_script_fetcher_http_transaction_factory;
 142     scoped_ptr<net::FtpTransactionFactory>
 143         proxy_script_fetcher_ftp_transaction_factory;
 144     scoped_ptr<net::URLRequestJobFactory>
 145         proxy_script_fetcher_url_request_job_factory;
 146     scoped_ptr<net::URLRequestThrottlerManager> throttler_manager;
 147     scoped_ptr<net::URLSecurityManager> url_security_manager;
 148     // TODO(willchan): Remove proxy script fetcher context since it's not
 149     // necessary now that I got rid of refcounting URLRequestContexts.
 150     //
 151     // The first URLRequestContext is |system_url_request_context|. We introduce
 152     // |proxy_script_fetcher_context| for the second context. It has a direct
 153     // ProxyService, since we always directly connect to fetch the PAC script.
 154     scoped_ptr<net::URLRequestContext> proxy_script_fetcher_context;
 155     scoped_ptr<net::ProxyService> system_proxy_service;
 156     scoped_ptr<net::HttpTransactionFactory> system_http_transaction_factory;
 157     scoped_ptr<net::URLRequestJobFactory> system_url_request_job_factory;
 158     scoped_ptr<net::URLRequestContext> system_request_context;
 159     SystemRequestContextLeakChecker system_request_context_leak_checker;
 160     // |system_cookie_store| and |system_channel_id_service| are shared
 161     // between |proxy_script_fetcher_context| and |system_request_context|.
 162     scoped_refptr<net::CookieStore> system_cookie_store;
 163 #if defined(ENABLE_EXTENSIONS)
 164     scoped_refptr<extensions::EventRouterForwarder>
 165         extension_event_router_forwarder;
 166 #endif
 167     scoped_ptr<net::HostMappingRules> host_mapping_rules;
 168     scoped_ptr<net::HttpUserAgentSettings> http_user_agent_settings;
 169     bool enable_ssl_connect_job_waiting;
 170     bool ignore_certificate_errors;
 171     uint16 testing_fixed_http_port;
 172     uint16 testing_fixed_https_port;
 173     Optional<bool> enable_tcp_fast_open_for_ssl;
 174
 175     Optional<size_t> initial_max_spdy_concurrent_streams;
 176     Optional<bool> force_spdy_single_domain;
 177     Optional<bool> enable_spdy_compression;
 178     Optional<bool> enable_spdy_ping_based_connection_checking;
 179     Optional<net::NextProto> spdy_default_protocol;
 180     net::NextProtoVector next_protos;
 181     Optional<string> trusted_spdy_proxy;
 182     Optional<bool> force_spdy_over_ssl;
 183     Optional<bool> force_spdy_always;
 184     std::set<net::HostPortPair> forced_spdy_exclusions;
 185     Optional<bool> use_alternate_protocols;
 186     Optional<double> alternate_protocol_probability_threshold;
 187     Optional<bool> enable_websocket_over_spdy;
 188
 189     Optional<bool> enable_quic;
 190     Optional<bool> enable_quic_time_based_loss_detection;
 191     Optional<bool> enable_quic_port_selection;
 192     Optional<bool> quic_always_require_handshake_confirmation;
 193     Optional<bool> quic_disable_connection_pooling;
 194     Optional<size_t> quic_max_packet_length;
 195     net::QuicTagVector quic_connection_options;
 196     Optional<std::string> quic_user_agent_id;
 197     Optional<net::QuicVersionVector> quic_supported_versions;
 198     Optional<net::HostPortPair> origin_to_force_quic_on;
 199     bool enable_user_alternate_protocol_ports;
 200     // NetErrorTabHelper uses |dns_probe_service| to send DNS probes when a
 201     // main frame load fails with a DNS error in order to provide more useful
 202     // information to the renderer so it can show a more specific error page.
 203     scoped_ptr<chrome_browser_net::DnsProbeService> dns_probe_service;
 204 #if defined(SPDY_PROXY_AUTH_ORIGIN)
 205   scoped_ptr<data_reduction_proxy::DataReductionProxyParams>
 206       data_reduction_proxy_params;
 207   scoped_ptr<data_reduction_proxy::DataReductionProxyAuthRequestHandler>
 208       data_reduction_proxy_auth_request_handler;
 209   scoped_ptr<data_reduction_proxy::DataReductionProxyDelegate>
 210       data_reduction_proxy_delegate;
 211 #endif
 212   };
 213
 214   // |net_log| must either outlive the IOThread or be NULL.
 215   IOThread(PrefService* local_state,
 216            policy::PolicyService* policy_service,
 217            ChromeNetLog* net_log,
 218            extensions::EventRouterForwarder* extension_event_router_forwarder);
 219
 220   virtual ~IOThread();
 221
 222   static void RegisterPrefs(PrefRegistrySimple* registry);
 223
 224   // Can only be called on the IO thread.
 225   Globals* globals();
 226
 227   // Allows overriding Globals in tests where IOThread::Init() and
 228   // IOThread::CleanUp() are not called.  This allows for injecting mocks into
 229   // IOThread global objects.
 230   void SetGlobalsForTesting(Globals* globals);
 231
 232   ChromeNetLog* net_log();
 233
 234   // Handles changing to On The Record mode, discarding confidential data.
 235   void ChangedToOnTheRecord();
 236
 237   // Returns a getter for the URLRequestContext.  Only called on the UI thread.
 238   net::URLRequestContextGetter* system_url_request_context_getter();
 239
 240   // Clears the host cache.  Intended to be used to prevent exposing recently
 241   // visited sites on about:net-internals/#dns and about:dns pages.  Must be
 242   // called on the IO thread.
 243   void ClearHostCache();
 244
 245   void InitializeNetworkSessionParams(net::HttpNetworkSession::Params* params);
 246
 247   base::TimeTicks creation_time() const;
 248
 249  private:
 250   // Map from name to value for all parameters associate with a field trial.
 251   typedef std::map<std::string, std::string> VariationParameters;
 252
 253   // Provide SystemURLRequestContextGetter with access to
 254   // InitSystemRequestContext().
 255   friend class SystemURLRequestContextGetter;
 256
 257   friend class test::IOThreadPeer;
 258
 259   // BrowserThreadDelegate implementation, runs on the IO thread.
 260   // This handles initialization and destruction of state that must
 261   // live on the IO thread.
 262   virtual void Init() OVERRIDE;
 263   virtual void InitAsync() OVERRIDE;
 264   virtual void CleanUp() OVERRIDE;
 265
 266   // Initializes |params| based on the settings in |globals|.
 267   static void InitializeNetworkSessionParamsFromGlobals(
 268       const Globals& globals,
 269       net::HttpNetworkSession::Params* params);
 270
 271   void InitializeNetworkOptions(const base::CommandLine& parsed_command_line);
 272
 273   // Sets up TCP FastOpen if enabled via field trials or via the command line.
 274   void ConfigureTCPFastOpen(const base::CommandLine& command_line);
 275
 276   // Enable SPDY with the given mode, which may contain the following:
 277   //
 278   //   "off"                      : Disables SPDY support entirely.
 279   //   "ssl"                      : Forces SPDY for all HTTPS requests.
 280   //   "no-ssl"                   : Forces SPDY for all HTTP requests.
 281   //   "no-ping"                  : Disables SPDY ping connection testing.
 282   //   "exclude=<host>"           : Disables SPDY support for the host <host>.
 283   //   "no-compress"              : Disables SPDY header compression.
 284   //   "no-alt-protocols          : Disables alternate protocol support.
 285   //   "force-alt-protocols       : Forces an alternate protocol of SPDY/3
 286   //                                on port 443.
 287   //   "single-domain"            : Forces all spdy traffic to a single domain.
 288   //   "init-max-streams=<limit>" : Specifies the maximum number of concurrent
 289   //                                streams for a SPDY session, unless the
 290   //                                specifies a different value via SETTINGS.
 291   void EnableSpdy(const std::string& mode);
 292
 293   // Configures available SPDY protocol versions from the given trial.
 294   // Used only if no command-line configuration was present.
 295   static void ConfigureSpdyFromTrial(const std::string& spdy_trial_group,
 296                                      Globals* globals);
 297
 298   // Global state must be initialized on the IO thread, then this
 299   // method must be invoked on the UI thread.
 300   void InitSystemRequestContext();
 301
 302   // Lazy initialization of system request context for
 303   // SystemURLRequestContextGetter. To be called on IO thread only
 304   // after global state has been initialized on the IO thread, and
 305   // SystemRequestContext state has been initialized on the UI thread.
 306   void InitSystemRequestContextOnIOThread();
 307
 308   net::HttpAuthHandlerFactory* CreateDefaultAuthHandlerFactory(
 309       net::HostResolver* resolver);
 310
 311   // Returns an SSLConfigService instance.
 312   net::SSLConfigService* GetSSLConfigService();
 313
 314   void ChangedToOnTheRecordOnIOThread();
 315
 316   void UpdateDnsClientEnabled();
 317
 318   // Configures QUIC options based on the flags in |command_line| as
 319   // well as the QUIC field trial group.
 320   void ConfigureQuic(const base::CommandLine& command_line);
 321
 322   extensions::EventRouterForwarder* extension_event_router_forwarder() {
 323 #if defined(ENABLE_EXTENSIONS)
 324     return extension_event_router_forwarder_;
 325 #else
 326     return NULL;
 327 #endif
 328   }
 329   // Configures QUIC options in |globals| based on the flags in |command_line|
 330   // as well as the QUIC field trial group and parameters.
 331   static void ConfigureQuicGlobals(
 332       const base::CommandLine& command_line,
 333       base::StringPiece quic_trial_group,
 334       const VariationParameters& quic_trial_params,
 335       Globals* globals);
 336
 337   // Returns true if QUIC should be enabled, either as a result
 338   // of a field trial or a command line flag.
 339   static bool ShouldEnableQuic(
 340       const base::CommandLine& command_line,
 341       base::StringPiece quic_trial_group);
 342
 343   // Returns true if the selection of the ephemeral port in bind() should be
 344   // performed by Chromium, and false if the OS should select the port.  The OS
 345   // option is used to prevent Windows from posting a security security warning
 346   // dialog.
 347   static bool ShouldEnableQuicPortSelection(
 348       const base::CommandLine& command_line);
 349
 350   // Returns true if QUIC packet pacing should be negotiated during the
 351   // QUIC handshake.
 352   static bool ShouldEnableQuicPacing(
 353       const base::CommandLine& command_line,
 354       base::StringPiece quic_trial_group,
 355       const VariationParameters& quic_trial_params);
 356
 357   // Returns true if QUIC time-base loss detection should be negotiated during
 358   // the QUIC handshake.
 359   static bool ShouldEnableQuicTimeBasedLossDetection(
 360       const base::CommandLine& command_line,
 361       base::StringPiece quic_trial_group,
 362       const VariationParameters& quic_trial_params);
 363
 364   // Returns true if QUIC should always require handshake confirmation during
 365   // the QUIC handshake.
 366   static bool ShouldQuicAlwaysRequireHandshakeConfirmation(
 367       const VariationParameters& quic_trial_params);
 368
 369   // Returns true if QUIC should disable connection pooling.
 370   static bool ShouldQuicDisableConnectionPooling(
 371       const VariationParameters& quic_trial_params);
 372
 373   // Returns the maximum length for QUIC packets, based on any flags in
 374   // |command_line| or the field trial.  Returns 0 if there is an error
 375   // parsing any of the options, or if the default value should be used.
 376   static size_t GetQuicMaxPacketLength(
 377       const base::CommandLine& command_line,
 378       base::StringPiece quic_trial_group,
 379       const VariationParameters& quic_trial_params);
 380
 381   // Returns the QUIC versions specified by any flags in |command_line|
 382   // or |quic_trial_params|.
 383   static net::QuicVersion GetQuicVersion(
 384       const base::CommandLine& command_line,
 385       const VariationParameters& quic_trial_params);
 386
 387   // Returns the QUIC version specified by |quic_version| or
 388   // QUIC_VERSION_UNSUPPORTED if |quic_version| is invalid.
 389   static net::QuicVersion ParseQuicVersion(const std::string& quic_version);
 390
 391   // Returns the QUIC connection options specified by any flags in
 392   // |command_line| or |quic_trial_params|.
 393   static net::QuicTagVector GetQuicConnectionOptions(
 394       const base::CommandLine& command_line,
 395       const VariationParameters& quic_trial_params);
 396
 397   // Returns the list of QUIC tags represented by the comma separated
 398   // string in |connection_options|.
 399   static net::QuicTagVector ParseQuicConnectionOptions(
 400       const std::string& connection_options);
 401
 402   // Returns the alternate protocol probability threshold specified by
 403   // any flags in |command_line| or |quic_trial_params|.
 404   static double GetAlternateProtocolProbabilityThreshold(
 405       const base::CommandLine& command_line,
 406       const VariationParameters& quic_trial_params);
 407
 408   // The NetLog is owned by the browser process, to allow logging from other
 409   // threads during shutdown, but is used most frequently on the IOThread.
 410   ChromeNetLog* net_log_;
 411
 412 #if defined(ENABLE_EXTENSIONS)
 413   // The extensions::EventRouterForwarder allows for sending events to
 414   // extensions from the IOThread.
 415   extensions::EventRouterForwarder* extension_event_router_forwarder_;
 416 #endif
 417
 418   // These member variables are basically global, but their lifetimes are tied
 419   // to the IOThread.  IOThread owns them all, despite not using scoped_ptr.
 420   // This is because the destructor of IOThread runs on the wrong thread.  All
 421   // member variables should be deleted in CleanUp().
 422
 423   // These member variables are initialized in Init() and do not change for the
 424   // lifetime of the IO thread.
 425
 426   Globals* globals_;
 427
 428   // Observer that logs network changes to the ChromeNetLog.
 429   class LoggingNetworkChangeObserver;
 430   scoped_ptr<LoggingNetworkChangeObserver> network_change_observer_;
 431
 432   BooleanPrefMember system_enable_referrers_;
 433
 434   BooleanPrefMember dns_client_enabled_;
 435
 436   BooleanPrefMember quick_check_enabled_;
 437
 438   // Store HTTP Auth-related policies in this thread.
 439   std::string auth_schemes_;
 440   bool negotiate_disable_cname_lookup_;
 441   bool negotiate_enable_port_;
 442   std::string auth_server_whitelist_;
 443   std::string auth_delegate_whitelist_;
 444   std::string gssapi_library_name_;
 445
 446   // This is an instance of the default SSLConfigServiceManager for the current
 447   // platform and it gets SSL preferences from local_state object.
 448   scoped_ptr<SSLConfigServiceManager> ssl_config_service_manager_;
 449
 450   // These member variables are initialized by a task posted to the IO thread,
 451   // which gets posted by calling certain member functions of IOThread.
 452   scoped_ptr<net::ProxyConfigService> system_proxy_config_service_;
 453
 454   scoped_ptr<PrefProxyConfigTracker> pref_proxy_config_tracker_;
 455
 456   scoped_refptr<net::URLRequestContextGetter>
 457       system_url_request_context_getter_;
 458
 459   // True if SPDY is disabled by policy.
 460   bool is_spdy_disabled_by_policy_;
 461
 462   const base::TimeTicks creation_time_;
 463
 464   base::WeakPtrFactory<IOThread> weak_factory_;
 465
 466   DISALLOW_COPY_AND_ASSIGN(IOThread);
 467 };
 468
 469 #endif  // CHROME_BROWSER_IO_THREAD_H_