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.
5 #ifndef CHROME_BROWSER_IO_THREAD_H_
6 #define CHROME_BROWSER_IO_THREAD_H_
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/strings/string_piece.h"
18 #include "base/time/time.h"
19 #include "chrome/browser/net/chrome_network_delegate.h"
20 #include "chrome/browser/net/ssl_config_service_manager.h"
21 #include "content/public/browser/browser_thread.h"
22 #include "content/public/browser/browser_thread_delegate.h"
23 #include "net/base/network_change_notifier.h"
24 #include "net/http/http_network_session.h"
25 #include "net/socket/next_proto.h"
28 class PrefProxyConfigTracker;
30 class PrefRegistrySimple;
31 class SystemURLRequestContextGetter;
37 namespace chrome_browser_net {
38 class DnsProbeService;
41 namespace data_reduction_proxy {
42 class DataReductionProxyAuthRequestHandler;
43 class DataReductionProxyDelegate;
44 class DataReductionProxyParams;
47 namespace extensions {
48 class EventRouterForwarder;
53 class ChannelIDService;
56 class FtpTransactionFactory;
57 class HostMappingRules;
59 class HttpAuthHandlerFactory;
60 class HttpServerProperties;
61 class HttpTransactionFactory;
62 class HttpUserAgentSettings;
63 class NetworkDelegate;
64 class ProxyConfigService;
66 class SSLConfigService;
67 class TransportSecurityState;
68 class URLRequestContext;
69 class URLRequestContextGetter;
70 class URLRequestJobFactory;
71 class URLRequestThrottlerManager;
72 class URLSecurityManager;
83 // Contains state associated with, initialized and cleaned up on, and
84 // primarily used on, the IO thread.
86 // If you are looking to interact with the IO thread (e.g. post tasks
87 // to it or check if it is the current thread), see
88 // content::BrowserThread.
89 class IOThread : public content::BrowserThreadDelegate {
95 Optional() : set_(false) {}
101 void CopyToIfSet(T* value) const {
112 class SystemRequestContextLeakChecker {
114 explicit SystemRequestContextLeakChecker(Globals* globals);
115 ~SystemRequestContextLeakChecker();
118 Globals* const globals_;
124 // The "system" NetworkDelegate, used for Profile-agnostic network events.
125 scoped_ptr<net::NetworkDelegate> system_network_delegate;
126 scoped_ptr<net::HostResolver> host_resolver;
127 scoped_ptr<net::CertVerifier> cert_verifier;
128 // The ChannelIDService must outlive the HttpTransactionFactory.
129 scoped_ptr<net::ChannelIDService> system_channel_id_service;
130 // This TransportSecurityState doesn't load or save any state. It's only
131 // used to enforce pinning for system requests and will only use built-in
133 scoped_ptr<net::TransportSecurityState> transport_security_state;
134 scoped_ptr<net::CTVerifier> cert_transparency_verifier;
135 scoped_refptr<net::SSLConfigService> ssl_config_service;
136 scoped_ptr<net::HttpAuthHandlerFactory> http_auth_handler_factory;
137 scoped_ptr<net::HttpServerProperties> http_server_properties;
138 scoped_ptr<net::ProxyService> proxy_script_fetcher_proxy_service;
139 scoped_ptr<net::HttpTransactionFactory>
140 proxy_script_fetcher_http_transaction_factory;
141 scoped_ptr<net::FtpTransactionFactory>
142 proxy_script_fetcher_ftp_transaction_factory;
143 scoped_ptr<net::URLRequestJobFactory>
144 proxy_script_fetcher_url_request_job_factory;
145 scoped_ptr<net::URLRequestThrottlerManager> throttler_manager;
146 scoped_ptr<net::URLSecurityManager> url_security_manager;
147 // TODO(willchan): Remove proxy script fetcher context since it's not
148 // necessary now that I got rid of refcounting URLRequestContexts.
150 // The first URLRequestContext is |system_url_request_context|. We introduce
151 // |proxy_script_fetcher_context| for the second context. It has a direct
152 // ProxyService, since we always directly connect to fetch the PAC script.
153 scoped_ptr<net::URLRequestContext> proxy_script_fetcher_context;
154 scoped_ptr<net::ProxyService> system_proxy_service;
155 scoped_ptr<net::HttpTransactionFactory> system_http_transaction_factory;
156 scoped_ptr<net::URLRequestJobFactory> system_url_request_job_factory;
157 scoped_ptr<net::URLRequestContext> system_request_context;
158 SystemRequestContextLeakChecker system_request_context_leak_checker;
159 // |system_cookie_store| and |system_channel_id_service| are shared
160 // between |proxy_script_fetcher_context| and |system_request_context|.
161 scoped_refptr<net::CookieStore> system_cookie_store;
162 #if defined(ENABLE_EXTENSIONS)
163 scoped_refptr<extensions::EventRouterForwarder>
164 extension_event_router_forwarder;
166 scoped_ptr<net::HostMappingRules> host_mapping_rules;
167 scoped_ptr<net::HttpUserAgentSettings> http_user_agent_settings;
168 bool enable_ssl_connect_job_waiting;
169 bool ignore_certificate_errors;
170 bool use_stale_while_revalidate;
171 uint16 testing_fixed_http_port;
172 uint16 testing_fixed_https_port;
173 Optional<bool> enable_tcp_fast_open_for_ssl;
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;
189 Optional<bool> enable_quic;
190 Optional<bool> enable_quic_port_selection;
191 Optional<bool> quic_always_require_handshake_confirmation;
192 Optional<bool> quic_disable_connection_pooling;
193 Optional<int> quic_load_server_info_timeout_ms;
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 scoped_ptr<data_reduction_proxy::DataReductionProxyParams>
205 data_reduction_proxy_params;
206 scoped_ptr<data_reduction_proxy::DataReductionProxyAuthRequestHandler>
207 data_reduction_proxy_auth_request_handler;
208 scoped_ptr<data_reduction_proxy::DataReductionProxyDelegate>
209 data_reduction_proxy_delegate;
212 // |net_log| must either outlive the IOThread or be NULL.
213 IOThread(PrefService* local_state,
214 policy::PolicyService* policy_service,
215 ChromeNetLog* net_log,
216 extensions::EventRouterForwarder* extension_event_router_forwarder);
218 ~IOThread() override;
220 static void RegisterPrefs(PrefRegistrySimple* registry);
222 // Can only be called on the IO thread.
225 // Allows overriding Globals in tests where IOThread::Init() and
226 // IOThread::CleanUp() are not called. This allows for injecting mocks into
227 // IOThread global objects.
228 void SetGlobalsForTesting(Globals* globals);
230 ChromeNetLog* net_log();
232 // Handles changing to On The Record mode, discarding confidential data.
233 void ChangedToOnTheRecord();
235 // Returns a getter for the URLRequestContext. Only called on the UI thread.
236 net::URLRequestContextGetter* system_url_request_context_getter();
238 // Clears the host cache. Intended to be used to prevent exposing recently
239 // visited sites on about:net-internals/#dns and about:dns pages. Must be
240 // called on the IO thread.
241 void ClearHostCache();
243 void InitializeNetworkSessionParams(net::HttpNetworkSession::Params* params);
245 base::TimeTicks creation_time() const;
248 // Map from name to value for all parameters associate with a field trial.
249 typedef std::map<std::string, std::string> VariationParameters;
251 // Provide SystemURLRequestContextGetter with access to
252 // InitSystemRequestContext().
253 friend class SystemURLRequestContextGetter;
255 friend class test::IOThreadPeer;
257 // BrowserThreadDelegate implementation, runs on the IO thread.
258 // This handles initialization and destruction of state that must
259 // live on the IO thread.
260 void Init() override;
261 void InitAsync() override;
262 void CleanUp() override;
264 // Initializes |params| based on the settings in |globals|.
265 static void InitializeNetworkSessionParamsFromGlobals(
266 const Globals& globals,
267 net::HttpNetworkSession::Params* params);
269 void InitializeNetworkOptions(const base::CommandLine& parsed_command_line);
271 // Sets up TCP FastOpen if enabled via field trials or via the command line.
272 void ConfigureTCPFastOpen(const base::CommandLine& command_line);
274 // Enable SPDY with the given mode, which may contain the following:
276 // "off" : Disables SPDY support entirely.
277 // "ssl" : Forces SPDY for all HTTPS requests.
278 // "no-ssl" : Forces SPDY for all HTTP requests.
279 // "no-ping" : Disables SPDY ping connection testing.
280 // "exclude=<host>" : Disables SPDY support for the host <host>.
281 // "no-compress" : Disables SPDY header compression.
282 // "no-alt-protocols : Disables alternate protocol support.
283 // "force-alt-protocols : Forces an alternate protocol of SPDY/3
285 // "single-domain" : Forces all spdy traffic to a single domain.
286 // "init-max-streams=<limit>" : Specifies the maximum number of concurrent
287 // streams for a SPDY session, unless the
288 // specifies a different value via SETTINGS.
289 void EnableSpdy(const std::string& mode);
291 // Configures available SPDY protocol versions from the given trial.
292 // Used only if no command-line configuration was present.
293 static void ConfigureSpdyFromTrial(base::StringPiece spdy_trial_group,
296 // Global state must be initialized on the IO thread, then this
297 // method must be invoked on the UI thread.
298 void InitSystemRequestContext();
300 // Lazy initialization of system request context for
301 // SystemURLRequestContextGetter. To be called on IO thread only
302 // after global state has been initialized on the IO thread, and
303 // SystemRequestContext state has been initialized on the UI thread.
304 void InitSystemRequestContextOnIOThread();
306 net::HttpAuthHandlerFactory* CreateDefaultAuthHandlerFactory(
307 net::HostResolver* resolver);
309 // Returns an SSLConfigService instance.
310 net::SSLConfigService* GetSSLConfigService();
312 void ChangedToOnTheRecordOnIOThread();
314 void UpdateDnsClientEnabled();
316 // Configures QUIC options based on the flags in |command_line| as
317 // well as the QUIC field trial group.
318 void ConfigureQuic(const base::CommandLine& command_line);
320 // Set up data reduction proxy related objects on IO thread globals.
321 void SetupDataReductionProxy(ChromeNetworkDelegate* network_delegate);
323 extensions::EventRouterForwarder* extension_event_router_forwarder() {
324 #if defined(ENABLE_EXTENSIONS)
325 return extension_event_router_forwarder_;
330 // Configures QUIC options in |globals| based on the flags in |command_line|
331 // as well as the QUIC field trial group and parameters.
332 static void ConfigureQuicGlobals(
333 const base::CommandLine& command_line,
334 base::StringPiece quic_trial_group,
335 const VariationParameters& quic_trial_params,
338 // Returns true if QUIC should be enabled, either as a result
339 // of a field trial or a command line flag.
340 static bool ShouldEnableQuic(
341 const base::CommandLine& command_line,
342 base::StringPiece quic_trial_group);
344 // Returns true if the selection of the ephemeral port in bind() should be
345 // performed by Chromium, and false if the OS should select the port. The OS
346 // option is used to prevent Windows from posting a security security warning
348 static bool ShouldEnableQuicPortSelection(
349 const base::CommandLine& command_line);
351 // Returns true if QUIC packet pacing should be negotiated during the
353 static bool ShouldEnableQuicPacing(
354 const base::CommandLine& command_line,
355 base::StringPiece quic_trial_group,
356 const VariationParameters& quic_trial_params);
358 // Returns true if QUIC should always require handshake confirmation during
359 // the QUIC handshake.
360 static bool ShouldQuicAlwaysRequireHandshakeConfirmation(
361 const VariationParameters& quic_trial_params);
363 // Returns true if QUIC should disable connection pooling.
364 static bool ShouldQuicDisableConnectionPooling(
365 const VariationParameters& quic_trial_params);
367 // Returns the timeout value for loading of QUIC sever information from disk
368 // cache base on field trial. Returns 0 if there is an error parsing the
369 // field trial params, or if the default value should be used.
370 static int GetQuicLoadServerInfoTimeout(
371 const VariationParameters& quic_trial_params);
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);
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);
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);
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);
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);
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);
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_;
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_;
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().
423 // These member variables are initialized in Init() and do not change for the
424 // lifetime of the IO thread.
428 // Observer that logs network changes to the ChromeNetLog.
429 class LoggingNetworkChangeObserver;
430 scoped_ptr<LoggingNetworkChangeObserver> network_change_observer_;
432 BooleanPrefMember system_enable_referrers_;
434 BooleanPrefMember dns_client_enabled_;
436 BooleanPrefMember quick_check_enabled_;
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_;
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_;
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_;
454 scoped_ptr<PrefProxyConfigTracker> pref_proxy_config_tracker_;
456 scoped_refptr<net::URLRequestContextGetter>
457 system_url_request_context_getter_;
459 // True if SPDY is disabled by policy.
460 bool is_spdy_disabled_by_policy_;
462 const base::TimeTicks creation_time_;
464 base::WeakPtrFactory<IOThread> weak_factory_;
466 DISALLOW_COPY_AND_ASSIGN(IOThread);
469 #endif // CHROME_BROWSER_IO_THREAD_H_