Cast: Stop logging kVideoFrameSentToEncoder and rename a couple events.
[chromium-blink-merge.git] / chrome / browser / io_thread.cc
blob29a65ea48f601176a962665995c2e1a324cddbaa
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 #include "chrome/browser/io_thread.h"
7 #include <vector>
9 #include "base/base64.h"
10 #include "base/bind.h"
11 #include "base/bind_helpers.h"
12 #include "base/command_line.h"
13 #include "base/compiler_specific.h"
14 #include "base/debug/leak_tracker.h"
15 #include "base/debug/trace_event.h"
16 #include "base/logging.h"
17 #include "base/metrics/field_trial.h"
18 #include "base/prefs/pref_registry_simple.h"
19 #include "base/prefs/pref_service.h"
20 #include "base/stl_util.h"
21 #include "base/strings/string_number_conversions.h"
22 #include "base/strings/string_split.h"
23 #include "base/strings/string_util.h"
24 #include "base/threading/sequenced_worker_pool.h"
25 #include "base/threading/thread.h"
26 #include "base/threading/worker_pool.h"
27 #include "base/time/default_tick_clock.h"
28 #include "base/time/time.h"
29 #include "build/build_config.h"
30 #include "chrome/browser/browser_process.h"
31 #include "chrome/browser/extensions/event_router_forwarder.h"
32 #include "chrome/browser/net/async_dns_field_trial.h"
33 #include "chrome/browser/net/chrome_net_log.h"
34 #include "chrome/browser/net/chrome_network_delegate.h"
35 #include "chrome/browser/net/chrome_url_request_context.h"
36 #include "chrome/browser/net/connect_interceptor.h"
37 #include "chrome/browser/net/dns_probe_service.h"
38 #include "chrome/browser/net/http_pipelining_compatibility_client.h"
39 #include "chrome/browser/net/pref_proxy_config_tracker.h"
40 #include "chrome/browser/net/proxy_service_factory.h"
41 #include "chrome/browser/net/sdch_dictionary_fetcher.h"
42 #include "chrome/common/chrome_content_client.h"
43 #include "chrome/common/chrome_switches.h"
44 #include "chrome/common/chrome_version_info.h"
45 #include "chrome/common/pref_names.h"
46 #include "chrome/common/url_constants.h"
47 #include "components/data_reduction_proxy/browser/data_reduction_proxy_prefs.h"
48 #include "components/data_reduction_proxy/browser/http_auth_handler_data_reduction_proxy.h"
49 #include "components/policy/core/common/policy_service.h"
50 #include "content/public/browser/browser_thread.h"
51 #include "content/public/browser/cookie_store_factory.h"
52 #include "net/base/host_mapping_rules.h"
53 #include "net/base/net_util.h"
54 #include "net/base/network_time_notifier.h"
55 #include "net/base/sdch_manager.h"
56 #include "net/cert/cert_verifier.h"
57 #include "net/cert/cert_verify_proc.h"
58 #include "net/cert/ct_known_logs.h"
59 #include "net/cert/ct_verifier.h"
60 #include "net/cert/multi_threaded_cert_verifier.h"
61 #include "net/cookies/cookie_store.h"
62 #include "net/dns/host_cache.h"
63 #include "net/dns/host_resolver.h"
64 #include "net/dns/mapped_host_resolver.h"
65 #include "net/ftp/ftp_network_layer.h"
66 #include "net/http/http_auth_filter.h"
67 #include "net/http/http_auth_handler_factory.h"
68 #include "net/http/http_network_layer.h"
69 #include "net/http/http_server_properties_impl.h"
70 #include "net/proxy/proxy_config_service.h"
71 #include "net/proxy/proxy_script_fetcher_impl.h"
72 #include "net/proxy/proxy_service.h"
73 #include "net/quic/quic_protocol.h"
74 #include "net/socket/tcp_client_socket.h"
75 #include "net/spdy/spdy_session.h"
76 #include "net/ssl/default_server_bound_cert_store.h"
77 #include "net/ssl/server_bound_cert_service.h"
78 #include "net/url_request/data_protocol_handler.h"
79 #include "net/url_request/file_protocol_handler.h"
80 #include "net/url_request/ftp_protocol_handler.h"
81 #include "net/url_request/static_http_user_agent_settings.h"
82 #include "net/url_request/url_fetcher.h"
83 #include "net/url_request/url_request_job_factory_impl.h"
84 #include "net/url_request/url_request_throttler_manager.h"
85 #include "net/websockets/websocket_job.h"
87 #if defined(ENABLE_CONFIGURATION_POLICY)
88 #include "policy/policy_constants.h"
89 #endif
91 #if !defined(USE_OPENSSL)
92 #include "net/cert/ct_log_verifier.h"
93 #include "net/cert/multi_log_ct_verifier.h"
94 #endif
96 #if defined(USE_NSS) || defined(OS_IOS)
97 #include "net/ocsp/nss_ocsp.h"
98 #endif
100 #if defined(OS_ANDROID) || defined(OS_IOS)
101 #include "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
102 #endif
104 #if defined(OS_CHROMEOS)
105 #include "chrome/browser/chromeos/login/user_manager.h"
106 #include "chrome/browser/chromeos/net/cert_verify_proc_chromeos.h"
107 #endif
109 using content::BrowserThread;
111 #if defined(OS_ANDROID) || defined(OS_IOS)
112 using data_reduction_proxy::DataReductionProxySettings;
113 #endif
115 class SafeBrowsingURLRequestContext;
117 // The IOThread object must outlive any tasks posted to the IO thread before the
118 // Quit task, so base::Bind() calls are not refcounted.
120 namespace {
122 const char kQuicFieldTrialName[] = "QUIC";
123 const char kQuicFieldTrialEnabledGroupName[] = "Enabled";
124 const char kQuicFieldTrialHttpsEnabledGroupName[] = "HttpsEnabled";
125 const char kQuicFieldTrialPacketLengthSuffix[] = "BytePackets";
126 const char kQuicFieldTrialPacingSuffix[] = "WithPacing";
127 const char kQuicFieldTrialTimeBasedLossDetectionSuffix[] =
128 "WithTimeBasedLossDetection";
130 const char kSpdyFieldTrialName[] = "SPDY";
131 const char kSpdyFieldTrialDisabledGroupName[] = "SpdyDisabled";
133 #if defined(OS_MACOSX) && !defined(OS_IOS)
134 void ObserveKeychainEvents() {
135 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
136 net::CertDatabase::GetInstance()->SetMessageLoopForKeychainEvents();
138 #endif
140 // Used for the "system" URLRequestContext.
141 class SystemURLRequestContext : public net::URLRequestContext {
142 public:
143 SystemURLRequestContext() {
144 #if defined(USE_NSS) || defined(OS_IOS)
145 net::SetURLRequestContextForNSSHttpIO(this);
146 #endif
149 private:
150 virtual ~SystemURLRequestContext() {
151 #if defined(USE_NSS) || defined(OS_IOS)
152 net::SetURLRequestContextForNSSHttpIO(NULL);
153 #endif
157 scoped_ptr<net::HostResolver> CreateGlobalHostResolver(net::NetLog* net_log) {
158 TRACE_EVENT0("startup", "IOThread::CreateGlobalHostResolver");
159 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
161 net::HostResolver::Options options;
163 // Use the concurrency override from the command-line, if any.
164 if (command_line.HasSwitch(switches::kHostResolverParallelism)) {
165 std::string s =
166 command_line.GetSwitchValueASCII(switches::kHostResolverParallelism);
168 // Parse the switch (it should be a positive integer formatted as decimal).
169 int n;
170 if (base::StringToInt(s, &n) && n > 0) {
171 options.max_concurrent_resolves = static_cast<size_t>(n);
172 } else {
173 LOG(ERROR) << "Invalid switch for host resolver parallelism: " << s;
177 // Use the retry attempts override from the command-line, if any.
178 if (command_line.HasSwitch(switches::kHostResolverRetryAttempts)) {
179 std::string s =
180 command_line.GetSwitchValueASCII(switches::kHostResolverRetryAttempts);
181 // Parse the switch (it should be a non-negative integer).
182 int n;
183 if (base::StringToInt(s, &n) && n >= 0) {
184 options.max_retry_attempts = static_cast<size_t>(n);
185 } else {
186 LOG(ERROR) << "Invalid switch for host resolver retry attempts: " << s;
190 scoped_ptr<net::HostResolver> global_host_resolver(
191 net::HostResolver::CreateSystemResolver(options, net_log));
193 // Determine if we should disable IPv6 support.
194 if (command_line.HasSwitch(switches::kEnableIPv6)) {
195 // Disable IPv6 probing.
196 global_host_resolver->SetDefaultAddressFamily(
197 net::ADDRESS_FAMILY_UNSPECIFIED);
198 } else if (command_line.HasSwitch(switches::kDisableIPv6)) {
199 global_host_resolver->SetDefaultAddressFamily(net::ADDRESS_FAMILY_IPV4);
202 // If hostname remappings were specified on the command-line, layer these
203 // rules on top of the real host resolver. This allows forwarding all requests
204 // through a designated test server.
205 if (!command_line.HasSwitch(switches::kHostResolverRules))
206 return global_host_resolver.PassAs<net::HostResolver>();
208 scoped_ptr<net::MappedHostResolver> remapped_resolver(
209 new net::MappedHostResolver(global_host_resolver.Pass()));
210 remapped_resolver->SetRulesFromString(
211 command_line.GetSwitchValueASCII(switches::kHostResolverRules));
212 return remapped_resolver.PassAs<net::HostResolver>();
215 // TODO(willchan): Remove proxy script fetcher context since it's not necessary
216 // now that I got rid of refcounting URLRequestContexts.
217 // See IOThread::Globals for details.
218 net::URLRequestContext*
219 ConstructProxyScriptFetcherContext(IOThread::Globals* globals,
220 net::NetLog* net_log) {
221 net::URLRequestContext* context = new net::URLRequestContext;
222 context->set_net_log(net_log);
223 context->set_host_resolver(globals->host_resolver.get());
224 context->set_cert_verifier(globals->cert_verifier.get());
225 context->set_transport_security_state(
226 globals->transport_security_state.get());
227 context->set_cert_transparency_verifier(
228 globals->cert_transparency_verifier.get());
229 context->set_http_auth_handler_factory(
230 globals->http_auth_handler_factory.get());
231 context->set_proxy_service(globals->proxy_script_fetcher_proxy_service.get());
232 context->set_http_transaction_factory(
233 globals->proxy_script_fetcher_http_transaction_factory.get());
234 context->set_job_factory(
235 globals->proxy_script_fetcher_url_request_job_factory.get());
236 context->set_cookie_store(globals->system_cookie_store.get());
237 context->set_server_bound_cert_service(
238 globals->system_server_bound_cert_service.get());
239 context->set_network_delegate(globals->system_network_delegate.get());
240 context->set_http_user_agent_settings(
241 globals->http_user_agent_settings.get());
242 // TODO(rtenneti): We should probably use HttpServerPropertiesManager for the
243 // system URLRequestContext too. There's no reason this should be tied to a
244 // profile.
245 return context;
248 net::URLRequestContext*
249 ConstructSystemRequestContext(IOThread::Globals* globals,
250 net::NetLog* net_log) {
251 net::URLRequestContext* context = new SystemURLRequestContext;
252 context->set_net_log(net_log);
253 context->set_host_resolver(globals->host_resolver.get());
254 context->set_cert_verifier(globals->cert_verifier.get());
255 context->set_transport_security_state(
256 globals->transport_security_state.get());
257 context->set_cert_transparency_verifier(
258 globals->cert_transparency_verifier.get());
259 context->set_http_auth_handler_factory(
260 globals->http_auth_handler_factory.get());
261 context->set_proxy_service(globals->system_proxy_service.get());
262 context->set_http_transaction_factory(
263 globals->system_http_transaction_factory.get());
264 context->set_cookie_store(globals->system_cookie_store.get());
265 context->set_server_bound_cert_service(
266 globals->system_server_bound_cert_service.get());
267 context->set_throttler_manager(globals->throttler_manager.get());
268 context->set_network_delegate(globals->system_network_delegate.get());
269 context->set_http_user_agent_settings(
270 globals->http_user_agent_settings.get());
271 return context;
274 int GetSwitchValueAsInt(const CommandLine& command_line,
275 const std::string& switch_name) {
276 int value;
277 if (!base::StringToInt(command_line.GetSwitchValueASCII(switch_name),
278 &value)) {
279 return 0;
281 return value;
284 } // namespace
286 class IOThread::LoggingNetworkChangeObserver
287 : public net::NetworkChangeNotifier::IPAddressObserver,
288 public net::NetworkChangeNotifier::ConnectionTypeObserver,
289 public net::NetworkChangeNotifier::NetworkChangeObserver {
290 public:
291 // |net_log| must remain valid throughout our lifetime.
292 explicit LoggingNetworkChangeObserver(net::NetLog* net_log)
293 : net_log_(net_log) {
294 net::NetworkChangeNotifier::AddIPAddressObserver(this);
295 net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
296 net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
299 virtual ~LoggingNetworkChangeObserver() {
300 net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
301 net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
302 net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
305 // NetworkChangeNotifier::IPAddressObserver implementation.
306 virtual void OnIPAddressChanged() OVERRIDE {
307 VLOG(1) << "Observed a change to the network IP addresses";
309 net_log_->AddGlobalEntry(net::NetLog::TYPE_NETWORK_IP_ADDRESSES_CHANGED);
312 // NetworkChangeNotifier::ConnectionTypeObserver implementation.
313 virtual void OnConnectionTypeChanged(
314 net::NetworkChangeNotifier::ConnectionType type) OVERRIDE {
315 std::string type_as_string =
316 net::NetworkChangeNotifier::ConnectionTypeToString(type);
318 VLOG(1) << "Observed a change to network connectivity state "
319 << type_as_string;
321 net_log_->AddGlobalEntry(
322 net::NetLog::TYPE_NETWORK_CONNECTIVITY_CHANGED,
323 net::NetLog::StringCallback("new_connection_type", &type_as_string));
326 // NetworkChangeNotifier::NetworkChangeObserver implementation.
327 virtual void OnNetworkChanged(
328 net::NetworkChangeNotifier::ConnectionType type) OVERRIDE {
329 std::string type_as_string =
330 net::NetworkChangeNotifier::ConnectionTypeToString(type);
332 VLOG(1) << "Observed a network change to state " << type_as_string;
334 net_log_->AddGlobalEntry(
335 net::NetLog::TYPE_NETWORK_CHANGED,
336 net::NetLog::StringCallback("new_connection_type", &type_as_string));
339 private:
340 net::NetLog* net_log_;
341 DISALLOW_COPY_AND_ASSIGN(LoggingNetworkChangeObserver);
344 class SystemURLRequestContextGetter : public net::URLRequestContextGetter {
345 public:
346 explicit SystemURLRequestContextGetter(IOThread* io_thread);
348 // Implementation for net::UrlRequestContextGetter.
349 virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE;
350 virtual scoped_refptr<base::SingleThreadTaskRunner>
351 GetNetworkTaskRunner() const OVERRIDE;
353 protected:
354 virtual ~SystemURLRequestContextGetter();
356 private:
357 IOThread* const io_thread_; // Weak pointer, owned by BrowserProcess.
358 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
360 base::debug::LeakTracker<SystemURLRequestContextGetter> leak_tracker_;
363 SystemURLRequestContextGetter::SystemURLRequestContextGetter(
364 IOThread* io_thread)
365 : io_thread_(io_thread),
366 network_task_runner_(
367 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)) {
370 SystemURLRequestContextGetter::~SystemURLRequestContextGetter() {}
372 net::URLRequestContext* SystemURLRequestContextGetter::GetURLRequestContext() {
373 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
374 DCHECK(io_thread_->globals()->system_request_context.get());
376 return io_thread_->globals()->system_request_context.get();
379 scoped_refptr<base::SingleThreadTaskRunner>
380 SystemURLRequestContextGetter::GetNetworkTaskRunner() const {
381 return network_task_runner_;
384 IOThread::Globals::
385 SystemRequestContextLeakChecker::SystemRequestContextLeakChecker(
386 Globals* globals)
387 : globals_(globals) {
388 DCHECK(globals_);
391 IOThread::Globals::
392 SystemRequestContextLeakChecker::~SystemRequestContextLeakChecker() {
393 if (globals_->system_request_context.get())
394 globals_->system_request_context->AssertNoURLRequests();
397 IOThread::Globals::Globals()
398 : system_request_context_leak_checker(this),
399 ignore_certificate_errors(false),
400 http_pipelining_enabled(false),
401 testing_fixed_http_port(0),
402 testing_fixed_https_port(0),
403 enable_user_alternate_protocol_ports(false) {
406 IOThread::Globals::~Globals() {}
408 // |local_state| is passed in explicitly in order to (1) reduce implicit
409 // dependencies and (2) make IOThread more flexible for testing.
410 IOThread::IOThread(
411 PrefService* local_state,
412 policy::PolicyService* policy_service,
413 ChromeNetLog* net_log,
414 extensions::EventRouterForwarder* extension_event_router_forwarder)
415 : net_log_(net_log),
416 extension_event_router_forwarder_(extension_event_router_forwarder),
417 globals_(NULL),
418 sdch_manager_(NULL),
419 is_spdy_disabled_by_policy_(false),
420 weak_factory_(this),
421 creation_time_(base::TimeTicks::Now()) {
422 auth_schemes_ = local_state->GetString(prefs::kAuthSchemes);
423 negotiate_disable_cname_lookup_ = local_state->GetBoolean(
424 prefs::kDisableAuthNegotiateCnameLookup);
425 negotiate_enable_port_ = local_state->GetBoolean(
426 prefs::kEnableAuthNegotiatePort);
427 auth_server_whitelist_ = local_state->GetString(prefs::kAuthServerWhitelist);
428 auth_delegate_whitelist_ = local_state->GetString(
429 prefs::kAuthNegotiateDelegateWhitelist);
430 gssapi_library_name_ = local_state->GetString(prefs::kGSSAPILibraryName);
431 pref_proxy_config_tracker_.reset(
432 ProxyServiceFactory::CreatePrefProxyConfigTrackerOfLocalState(
433 local_state));
434 ChromeNetworkDelegate::InitializePrefsOnUIThread(
435 &system_enable_referrers_,
436 NULL,
437 NULL,
438 local_state);
439 ssl_config_service_manager_.reset(
440 SSLConfigServiceManager::CreateDefaultManager(local_state));
442 base::Value* dns_client_enabled_default = new base::FundamentalValue(
443 chrome_browser_net::ConfigureAsyncDnsFieldTrial());
444 local_state->SetDefaultPrefValue(prefs::kBuiltInDnsClientEnabled,
445 dns_client_enabled_default);
447 dns_client_enabled_.Init(prefs::kBuiltInDnsClientEnabled,
448 local_state,
449 base::Bind(&IOThread::UpdateDnsClientEnabled,
450 base::Unretained(this)));
451 dns_client_enabled_.MoveToThread(
452 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
454 quick_check_enabled_.Init(prefs::kQuickCheckEnabled,
455 local_state);
456 quick_check_enabled_.MoveToThread(
457 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
459 #if defined(ENABLE_CONFIGURATION_POLICY)
460 is_spdy_disabled_by_policy_ = policy_service->GetPolicies(
461 policy::PolicyNamespace(policy::POLICY_DOMAIN_CHROME, std::string())).Get(
462 policy::key::kDisableSpdy) != NULL;
463 #endif // ENABLE_CONFIGURATION_POLICY
465 BrowserThread::SetDelegate(BrowserThread::IO, this);
468 IOThread::~IOThread() {
469 // This isn't needed for production code, but in tests, IOThread may
470 // be multiply constructed.
471 BrowserThread::SetDelegate(BrowserThread::IO, NULL);
473 pref_proxy_config_tracker_->DetachFromPrefService();
474 DCHECK(!globals_);
477 IOThread::Globals* IOThread::globals() {
478 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
479 return globals_;
482 void IOThread::SetGlobalsForTesting(Globals* globals) {
483 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
484 DCHECK(!globals || !globals_);
485 globals_ = globals;
488 ChromeNetLog* IOThread::net_log() {
489 return net_log_;
492 void IOThread::ChangedToOnTheRecord() {
493 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
494 BrowserThread::PostTask(
495 BrowserThread::IO,
496 FROM_HERE,
497 base::Bind(&IOThread::ChangedToOnTheRecordOnIOThread,
498 base::Unretained(this)));
501 net::URLRequestContextGetter* IOThread::system_url_request_context_getter() {
502 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
503 if (!system_url_request_context_getter_.get()) {
504 InitSystemRequestContext();
506 return system_url_request_context_getter_.get();
509 void IOThread::Init() {
510 // Prefer to use InitAsync unless you need initialization to block
511 // the UI thread
514 void IOThread::InitAsync() {
515 TRACE_EVENT0("startup", "IOThread::InitAsync");
516 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
518 #if defined(USE_NSS) || defined(OS_IOS)
519 net::SetMessageLoopForNSSHttpIO();
520 #endif
522 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
524 DCHECK(!globals_);
525 globals_ = new Globals;
527 // Add an observer that will emit network change events to the ChromeNetLog.
528 // Assuming NetworkChangeNotifier dispatches in FIFO order, we should be
529 // logging the network change before other IO thread consumers respond to it.
530 network_change_observer_.reset(
531 new LoggingNetworkChangeObserver(net_log_));
533 // Setup the HistogramWatcher to run on the IO thread.
534 net::NetworkChangeNotifier::InitHistogramWatcher();
536 globals_->extension_event_router_forwarder =
537 extension_event_router_forwarder_;
538 ChromeNetworkDelegate* network_delegate =
539 new ChromeNetworkDelegate(extension_event_router_forwarder_,
540 &system_enable_referrers_);
541 if (command_line.HasSwitch(switches::kEnableClientHints))
542 network_delegate->SetEnableClientHints();
543 if (command_line.HasSwitch(switches::kDisableExtensionsHttpThrottling))
544 network_delegate->NeverThrottleRequests();
545 globals_->system_network_delegate.reset(network_delegate);
546 globals_->host_resolver = CreateGlobalHostResolver(net_log_);
547 UpdateDnsClientEnabled();
548 #if defined(OS_CHROMEOS)
549 if (chromeos::UserManager::IsMultipleProfilesAllowed()) {
550 // Creates a CertVerifyProc that doesn't allow any profile-provided certs.
551 globals_->cert_verifier.reset(new net::MultiThreadedCertVerifier(
552 new chromeos::CertVerifyProcChromeOS()));
553 } else // NOLINT Fallthrough to normal verifier if multiprofiles not allowed.
554 #endif
556 globals_->cert_verifier.reset(new net::MultiThreadedCertVerifier(
557 net::CertVerifyProc::CreateDefault()));
559 globals_->transport_security_state.reset(new net::TransportSecurityState());
560 #if !defined(USE_OPENSSL)
561 // For now, Certificate Transparency is only implemented for platforms
562 // that use NSS.
563 net::MultiLogCTVerifier* ct_verifier = new net::MultiLogCTVerifier();
564 globals_->cert_transparency_verifier.reset(ct_verifier);
566 // Add built-in logs
567 ct_verifier->AddLog(net::ct::CreateGooglePilotLogVerifier().Pass());
568 ct_verifier->AddLog(net::ct::CreateGoogleAviatorLogVerifier().Pass());
569 ct_verifier->AddLog(net::ct::CreateGoogleRocketeerLogVerifier().Pass());
571 // Add logs from command line
572 if (command_line.HasSwitch(switches::kCertificateTransparencyLog)) {
573 std::string switch_value = command_line.GetSwitchValueASCII(
574 switches::kCertificateTransparencyLog);
575 std::vector<std::string> logs;
576 base::SplitString(switch_value, ',', &logs);
577 for (std::vector<std::string>::iterator it = logs.begin(); it != logs.end();
578 ++it) {
579 const std::string& curr_log = *it;
580 size_t delim_pos = curr_log.find(":");
581 CHECK(delim_pos != std::string::npos)
582 << "CT log description not provided (switch format"
583 " is 'description:base64_key')";
584 std::string log_description(curr_log.substr(0, delim_pos));
585 std::string ct_public_key_data;
586 CHECK(base::Base64Decode(curr_log.substr(delim_pos + 1),
587 &ct_public_key_data))
588 << "Unable to decode CT public key.";
589 scoped_ptr<net::CTLogVerifier> external_log_verifier(
590 net::CTLogVerifier::Create(ct_public_key_data, log_description));
591 CHECK(external_log_verifier) << "Unable to parse CT public key.";
592 VLOG(1) << "Adding log with description " << log_description;
593 ct_verifier->AddLog(external_log_verifier.Pass());
596 #else
597 if (command_line.HasSwitch(switches::kCertificateTransparencyLog)) {
598 LOG(DFATAL) << "Certificate Transparency is not yet supported in Chrome "
599 "builds using OpenSSL.";
601 #endif
602 globals_->ssl_config_service = GetSSLConfigService();
603 #if defined(OS_ANDROID) || defined(OS_IOS)
604 if (DataReductionProxySettings::IsIncludedInFieldTrialOrFlags()) {
605 spdyproxy_auth_origins_ =
606 DataReductionProxySettings::GetDataReductionProxies();
608 #endif // defined(OS_ANDROID) || defined(OS_IOS)
609 globals_->http_auth_handler_factory.reset(CreateDefaultAuthHandlerFactory(
610 globals_->host_resolver.get()));
611 globals_->http_server_properties.reset(new net::HttpServerPropertiesImpl());
612 // For the ProxyScriptFetcher, we use a direct ProxyService.
613 globals_->proxy_script_fetcher_proxy_service.reset(
614 net::ProxyService::CreateDirectWithNetLog(net_log_));
615 // In-memory cookie store.
616 globals_->system_cookie_store =
617 content::CreateCookieStore(content::CookieStoreConfig());
618 // In-memory server bound cert store.
619 globals_->system_server_bound_cert_service.reset(
620 new net::ServerBoundCertService(
621 new net::DefaultServerBoundCertStore(NULL),
622 base::WorkerPool::GetTaskRunner(true)));
623 globals_->dns_probe_service.reset(new chrome_browser_net::DnsProbeService());
624 globals_->host_mapping_rules.reset(new net::HostMappingRules());
625 globals_->http_user_agent_settings.reset(
626 new net::StaticHttpUserAgentSettings(std::string(), GetUserAgent()));
627 if (command_line.HasSwitch(switches::kHostRules)) {
628 TRACE_EVENT_BEGIN0("startup", "IOThread::InitAsync:SetRulesFromString");
629 globals_->host_mapping_rules->SetRulesFromString(
630 command_line.GetSwitchValueASCII(switches::kHostRules));
631 TRACE_EVENT_END0("startup", "IOThread::InitAsync:SetRulesFromString");
633 if (command_line.HasSwitch(switches::kIgnoreCertificateErrors))
634 globals_->ignore_certificate_errors = true;
635 if (command_line.HasSwitch(switches::kTestingFixedHttpPort)) {
636 globals_->testing_fixed_http_port =
637 GetSwitchValueAsInt(command_line, switches::kTestingFixedHttpPort);
639 if (command_line.HasSwitch(switches::kTestingFixedHttpsPort)) {
640 globals_->testing_fixed_https_port =
641 GetSwitchValueAsInt(command_line, switches::kTestingFixedHttpsPort);
643 ConfigureQuic(command_line);
644 if (command_line.HasSwitch(
645 switches::kEnableUserAlternateProtocolPorts)) {
646 globals_->enable_user_alternate_protocol_ports = true;
648 InitializeNetworkOptions(command_line);
650 net::HttpNetworkSession::Params session_params;
651 InitializeNetworkSessionParams(&session_params);
652 session_params.net_log = net_log_;
653 session_params.proxy_service =
654 globals_->proxy_script_fetcher_proxy_service.get();
656 TRACE_EVENT_BEGIN0("startup", "IOThread::InitAsync:HttpNetworkSession");
657 scoped_refptr<net::HttpNetworkSession> network_session(
658 new net::HttpNetworkSession(session_params));
659 globals_->proxy_script_fetcher_http_transaction_factory
660 .reset(new net::HttpNetworkLayer(network_session.get()));
661 TRACE_EVENT_END0("startup", "IOThread::InitAsync:HttpNetworkSession");
662 scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
663 new net::URLRequestJobFactoryImpl());
664 job_factory->SetProtocolHandler(content::kDataScheme,
665 new net::DataProtocolHandler());
666 job_factory->SetProtocolHandler(
667 content::kFileScheme,
668 new net::FileProtocolHandler(
669 content::BrowserThread::GetBlockingPool()->
670 GetTaskRunnerWithShutdownBehavior(
671 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
672 #if !defined(DISABLE_FTP_SUPPORT)
673 globals_->proxy_script_fetcher_ftp_transaction_factory.reset(
674 new net::FtpNetworkLayer(globals_->host_resolver.get()));
675 job_factory->SetProtocolHandler(
676 content::kFtpScheme,
677 new net::FtpProtocolHandler(
678 globals_->proxy_script_fetcher_ftp_transaction_factory.get()));
679 #endif
680 globals_->proxy_script_fetcher_url_request_job_factory =
681 job_factory.PassAs<net::URLRequestJobFactory>();
683 globals_->throttler_manager.reset(new net::URLRequestThrottlerManager());
684 globals_->throttler_manager->set_net_log(net_log_);
685 // Always done in production, disabled only for unit tests.
686 globals_->throttler_manager->set_enable_thread_checks(true);
688 globals_->proxy_script_fetcher_context.reset(
689 ConstructProxyScriptFetcherContext(globals_, net_log_));
691 globals_->network_time_notifier.reset(
692 new net::NetworkTimeNotifier(
693 scoped_ptr<base::TickClock>(new base::DefaultTickClock())));
695 sdch_manager_ = new net::SdchManager();
697 #if defined(OS_MACOSX) && !defined(OS_IOS)
698 // Start observing Keychain events. This needs to be done on the UI thread,
699 // as Keychain services requires a CFRunLoop.
700 BrowserThread::PostTask(BrowserThread::UI,
701 FROM_HERE,
702 base::Bind(&ObserveKeychainEvents));
703 #endif
705 // InitSystemRequestContext turns right around and posts a task back
706 // to the IO thread, so we can't let it run until we know the IO
707 // thread has started.
709 // Note that since we are at BrowserThread::Init time, the UI thread
710 // is blocked waiting for the thread to start. Therefore, posting
711 // this task to the main thread's message loop here is guaranteed to
712 // get it onto the message loop while the IOThread object still
713 // exists. However, the message might not be processed on the UI
714 // thread until after IOThread is gone, so use a weak pointer.
715 BrowserThread::PostTask(BrowserThread::UI,
716 FROM_HERE,
717 base::Bind(&IOThread::InitSystemRequestContext,
718 weak_factory_.GetWeakPtr()));
721 void IOThread::CleanUp() {
722 base::debug::LeakTracker<SafeBrowsingURLRequestContext>::CheckForLeaks();
724 delete sdch_manager_;
725 sdch_manager_ = NULL;
727 #if defined(USE_NSS) || defined(OS_IOS)
728 net::ShutdownNSSHttpIO();
729 #endif
731 system_url_request_context_getter_ = NULL;
733 // Release objects that the net::URLRequestContext could have been pointing
734 // to.
736 // Shutdown the HistogramWatcher on the IO thread.
737 net::NetworkChangeNotifier::ShutdownHistogramWatcher();
739 // This must be reset before the ChromeNetLog is destroyed.
740 network_change_observer_.reset();
742 system_proxy_config_service_.reset();
744 delete globals_;
745 globals_ = NULL;
747 base::debug::LeakTracker<SystemURLRequestContextGetter>::CheckForLeaks();
750 void IOThread::InitializeNetworkOptions(const CommandLine& command_line) {
751 // Only handle use-spdy command line flags if "spdy.disabled" preference is
752 // not disabled via policy.
753 if (is_spdy_disabled_by_policy_) {
754 base::FieldTrial* trial = base::FieldTrialList::Find(kSpdyFieldTrialName);
755 if (trial)
756 trial->Disable();
757 } else {
758 std::string spdy_trial_group =
759 base::FieldTrialList::FindFullName(kSpdyFieldTrialName);
761 if (command_line.HasSwitch(switches::kEnableWebSocketOverSpdy)) {
762 // Enable WebSocket over SPDY.
763 net::WebSocketJob::set_websocket_over_spdy_enabled(true);
766 if (command_line.HasSwitch(switches::kTrustedSpdyProxy)) {
767 globals_->trusted_spdy_proxy.set(
768 command_line.GetSwitchValueASCII(switches::kTrustedSpdyProxy));
770 if (command_line.HasSwitch(switches::kIgnoreUrlFetcherCertRequests))
771 net::URLFetcher::SetIgnoreCertificateRequests(true);
773 if (command_line.HasSwitch(switches::kUseSpdy)) {
774 std::string spdy_mode =
775 command_line.GetSwitchValueASCII(switches::kUseSpdy);
776 EnableSpdy(spdy_mode);
777 } else if (command_line.HasSwitch(switches::kEnableSpdy4)) {
778 net::HttpStreamFactory::EnableNpnSpdy4Http2();
779 } else if (command_line.HasSwitch(switches::kDisableSpdy31)) {
780 net::HttpStreamFactory::EnableNpnSpdy3();
781 } else if (command_line.HasSwitch(switches::kEnableNpnHttpOnly)) {
782 net::HttpStreamFactory::EnableNpnHttpOnly();
783 } else {
784 if (spdy_trial_group == kSpdyFieldTrialDisabledGroupName &&
785 !command_line.HasSwitch(switches::kEnableWebSocketOverSpdy)) {
786 net::HttpStreamFactory::set_spdy_enabled(false);
787 } else {
788 // Use SPDY/3.1 by default.
789 net::HttpStreamFactory::EnableNpnSpdy31();
794 // TODO(rch): Make the client socket factory a per-network session
795 // instance, constructed from a NetworkSession::Params, to allow us
796 // to move this option to IOThread::Globals &
797 // HttpNetworkSession::Params.
798 if (command_line.HasSwitch(switches::kEnableTcpFastOpen))
799 net::SetTCPFastOpenEnabled(true);
802 void IOThread::EnableSpdy(const std::string& mode) {
803 static const char kOff[] = "off";
804 static const char kSSL[] = "ssl";
805 static const char kDisableSSL[] = "no-ssl";
806 static const char kDisablePing[] = "no-ping";
807 static const char kExclude[] = "exclude"; // Hosts to exclude
808 static const char kDisableCompression[] = "no-compress";
809 static const char kDisableAltProtocols[] = "no-alt-protocols";
810 static const char kForceAltProtocols[] = "force-alt-protocols";
811 static const char kSingleDomain[] = "single-domain";
813 static const char kInitialMaxConcurrentStreams[] = "init-max-streams";
815 std::vector<std::string> spdy_options;
816 base::SplitString(mode, ',', &spdy_options);
818 for (std::vector<std::string>::iterator it = spdy_options.begin();
819 it != spdy_options.end(); ++it) {
820 const std::string& element = *it;
821 std::vector<std::string> name_value;
822 base::SplitString(element, '=', &name_value);
823 const std::string& option =
824 name_value.size() > 0 ? name_value[0] : std::string();
825 const std::string value =
826 name_value.size() > 1 ? name_value[1] : std::string();
828 if (option == kOff) {
829 net::HttpStreamFactory::set_spdy_enabled(false);
830 } else if (option == kDisableSSL) {
831 globals_->spdy_default_protocol.set(net::kProtoSPDY3);
832 net::HttpStreamFactory::set_force_spdy_over_ssl(false);
833 net::HttpStreamFactory::set_force_spdy_always(true);
834 } else if (option == kSSL) {
835 globals_->spdy_default_protocol.set(net::kProtoSPDY3);
836 net::HttpStreamFactory::set_force_spdy_over_ssl(true);
837 net::HttpStreamFactory::set_force_spdy_always(true);
838 } else if (option == kDisablePing) {
839 globals_->enable_spdy_ping_based_connection_checking.set(false);
840 } else if (option == kExclude) {
841 net::HttpStreamFactory::add_forced_spdy_exclusion(value);
842 } else if (option == kDisableCompression) {
843 globals_->enable_spdy_compression.set(false);
844 } else if (option == kDisableAltProtocols) {
845 net::HttpStreamFactory::set_use_alternate_protocols(false);
846 } else if (option == kForceAltProtocols) {
847 net::PortAlternateProtocolPair pair;
848 pair.port = 443;
849 pair.protocol = net::NPN_SPDY_3;
850 net::HttpServerPropertiesImpl::ForceAlternateProtocol(pair);
851 } else if (option == kSingleDomain) {
852 DVLOG(1) << "FORCING SINGLE DOMAIN";
853 globals_->force_spdy_single_domain.set(true);
854 } else if (option == kInitialMaxConcurrentStreams) {
855 int streams;
856 if (base::StringToInt(value, &streams))
857 globals_->initial_max_spdy_concurrent_streams.set(streams);
858 } else if (option.empty() && it == spdy_options.begin()) {
859 continue;
860 } else {
861 LOG(DFATAL) << "Unrecognized spdy option: " << option;
866 // static
867 void IOThread::RegisterPrefs(PrefRegistrySimple* registry) {
868 registry->RegisterStringPref(prefs::kAuthSchemes,
869 "basic,digest,ntlm,negotiate,"
870 "spdyproxy");
871 registry->RegisterBooleanPref(prefs::kDisableAuthNegotiateCnameLookup, false);
872 registry->RegisterBooleanPref(prefs::kEnableAuthNegotiatePort, false);
873 registry->RegisterStringPref(prefs::kAuthServerWhitelist, std::string());
874 registry->RegisterStringPref(prefs::kAuthNegotiateDelegateWhitelist,
875 std::string());
876 registry->RegisterStringPref(prefs::kGSSAPILibraryName, std::string());
877 registry->RegisterStringPref(
878 data_reduction_proxy::prefs::kDataReductionProxy, std::string());
879 registry->RegisterBooleanPref(prefs::kEnableReferrers, true);
880 data_reduction_proxy::RegisterPrefs(registry);
881 registry->RegisterBooleanPref(prefs::kBuiltInDnsClientEnabled, true);
882 registry->RegisterBooleanPref(prefs::kQuickCheckEnabled, true);
885 net::HttpAuthHandlerFactory* IOThread::CreateDefaultAuthHandlerFactory(
886 net::HostResolver* resolver) {
887 net::HttpAuthFilterWhitelist* auth_filter_default_credentials = NULL;
888 if (!auth_server_whitelist_.empty()) {
889 auth_filter_default_credentials =
890 new net::HttpAuthFilterWhitelist(auth_server_whitelist_);
892 net::HttpAuthFilterWhitelist* auth_filter_delegate = NULL;
893 if (!auth_delegate_whitelist_.empty()) {
894 auth_filter_delegate =
895 new net::HttpAuthFilterWhitelist(auth_delegate_whitelist_);
897 globals_->url_security_manager.reset(
898 net::URLSecurityManager::Create(auth_filter_default_credentials,
899 auth_filter_delegate));
900 std::vector<std::string> supported_schemes;
901 base::SplitString(auth_schemes_, ',', &supported_schemes);
903 scoped_ptr<net::HttpAuthHandlerRegistryFactory> registry_factory(
904 net::HttpAuthHandlerRegistryFactory::Create(
905 supported_schemes, globals_->url_security_manager.get(),
906 resolver, gssapi_library_name_, negotiate_disable_cname_lookup_,
907 negotiate_enable_port_));
909 if (!spdyproxy_auth_origins_.empty()) {
910 registry_factory->RegisterSchemeFactory(
911 "spdyproxy",
912 new data_reduction_proxy::HttpAuthHandlerDataReductionProxy::Factory(
913 spdyproxy_auth_origins_));
916 return registry_factory.release();
919 void IOThread::ClearHostCache() {
920 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
922 net::HostCache* host_cache = globals_->host_resolver->GetHostCache();
923 if (host_cache)
924 host_cache->clear();
927 void IOThread::InitializeNetworkSessionParams(
928 net::HttpNetworkSession::Params* params) {
929 params->host_resolver = globals_->host_resolver.get();
930 params->cert_verifier = globals_->cert_verifier.get();
931 params->server_bound_cert_service =
932 globals_->system_server_bound_cert_service.get();
933 params->transport_security_state = globals_->transport_security_state.get();
934 params->ssl_config_service = globals_->ssl_config_service.get();
935 params->http_auth_handler_factory = globals_->http_auth_handler_factory.get();
936 params->http_server_properties =
937 globals_->http_server_properties->GetWeakPtr();
938 params->network_delegate = globals_->system_network_delegate.get();
939 params->host_mapping_rules = globals_->host_mapping_rules.get();
940 params->ignore_certificate_errors = globals_->ignore_certificate_errors;
941 params->http_pipelining_enabled = globals_->http_pipelining_enabled;
942 params->testing_fixed_http_port = globals_->testing_fixed_http_port;
943 params->testing_fixed_https_port = globals_->testing_fixed_https_port;
945 globals_->initial_max_spdy_concurrent_streams.CopyToIfSet(
946 &params->spdy_initial_max_concurrent_streams);
947 globals_->force_spdy_single_domain.CopyToIfSet(
948 &params->force_spdy_single_domain);
949 globals_->enable_spdy_compression.CopyToIfSet(
950 &params->enable_spdy_compression);
951 globals_->enable_spdy_ping_based_connection_checking.CopyToIfSet(
952 &params->enable_spdy_ping_based_connection_checking);
953 globals_->spdy_default_protocol.CopyToIfSet(
954 &params->spdy_default_protocol);
955 globals_->trusted_spdy_proxy.CopyToIfSet(
956 &params->trusted_spdy_proxy);
957 globals_->enable_quic.CopyToIfSet(&params->enable_quic);
958 globals_->enable_quic_https.CopyToIfSet(&params->enable_quic_https);
959 globals_->enable_quic_pacing.CopyToIfSet(
960 &params->enable_quic_pacing);
961 globals_->enable_quic_time_based_loss_detection.CopyToIfSet(
962 &params->enable_quic_time_based_loss_detection);
963 globals_->enable_quic_persist_server_info.CopyToIfSet(
964 &params->enable_quic_persist_server_info);
965 globals_->enable_quic_port_selection.CopyToIfSet(
966 &params->enable_quic_port_selection);
967 globals_->quic_max_packet_length.CopyToIfSet(&params->quic_max_packet_length);
968 globals_->quic_supported_versions.CopyToIfSet(
969 &params->quic_supported_versions);
970 globals_->origin_to_force_quic_on.CopyToIfSet(
971 &params->origin_to_force_quic_on);
972 params->enable_user_alternate_protocol_ports =
973 globals_->enable_user_alternate_protocol_ports;
976 base::TimeTicks IOThread::creation_time() const {
977 return creation_time_;
980 net::SSLConfigService* IOThread::GetSSLConfigService() {
981 return ssl_config_service_manager_->Get();
984 void IOThread::ChangedToOnTheRecordOnIOThread() {
985 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
987 // Clear the host cache to avoid showing entries from the OTR session
988 // in about:net-internals.
989 ClearHostCache();
992 void IOThread::InitSystemRequestContext() {
993 if (system_url_request_context_getter_.get())
994 return;
995 // If we're in unit_tests, IOThread may not be run.
996 if (!BrowserThread::IsMessageLoopValid(BrowserThread::IO))
997 return;
998 system_proxy_config_service_.reset(
999 ProxyServiceFactory::CreateProxyConfigService(
1000 pref_proxy_config_tracker_.get()));
1001 system_url_request_context_getter_ =
1002 new SystemURLRequestContextGetter(this);
1003 // Safe to post an unretained this pointer, since IOThread is
1004 // guaranteed to outlive the IO BrowserThread.
1005 BrowserThread::PostTask(
1006 BrowserThread::IO,
1007 FROM_HERE,
1008 base::Bind(&IOThread::InitSystemRequestContextOnIOThread,
1009 base::Unretained(this)));
1012 void IOThread::InitSystemRequestContextOnIOThread() {
1013 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1014 DCHECK(!globals_->system_proxy_service.get());
1015 DCHECK(system_proxy_config_service_.get());
1017 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
1018 globals_->system_proxy_service.reset(
1019 ProxyServiceFactory::CreateProxyService(
1020 net_log_,
1021 globals_->proxy_script_fetcher_context.get(),
1022 globals_->system_network_delegate.get(),
1023 system_proxy_config_service_.release(),
1024 command_line,
1025 quick_check_enabled_.GetValue()));
1027 net::HttpNetworkSession::Params system_params;
1028 InitializeNetworkSessionParams(&system_params);
1029 system_params.net_log = net_log_;
1030 system_params.proxy_service = globals_->system_proxy_service.get();
1032 globals_->system_http_transaction_factory.reset(
1033 new net::HttpNetworkLayer(
1034 new net::HttpNetworkSession(system_params)));
1035 globals_->system_request_context.reset(
1036 ConstructSystemRequestContext(globals_, net_log_));
1038 sdch_manager_->set_sdch_fetcher(
1039 new SdchDictionaryFetcher(system_url_request_context_getter_.get()));
1042 void IOThread::UpdateDnsClientEnabled() {
1043 globals()->host_resolver->SetDnsClientEnabled(*dns_client_enabled_);
1046 void IOThread::ConfigureQuic(const CommandLine& command_line) {
1047 // Always fetch the field trial group to ensure it is reported correctly.
1048 // The command line flags will be associated with a group that is reported
1049 // so long as trial is actually queried.
1050 std::string quic_trial_group =
1051 base::FieldTrialList::FindFullName(kQuicFieldTrialName);
1053 bool enable_quic = ShouldEnableQuic(command_line, quic_trial_group);
1054 globals_->enable_quic.set(enable_quic);
1055 if (enable_quic) {
1056 globals_->enable_quic_https.set(
1057 ShouldEnableQuicHttps(command_line, quic_trial_group));
1058 globals_->enable_quic_pacing.set(
1059 ShouldEnableQuicPacing(command_line, quic_trial_group));
1060 globals_->enable_quic_time_based_loss_detection.set(
1061 ShouldEnableQuicTimeBasedLossDetection(command_line, quic_trial_group));
1062 globals_->enable_quic_persist_server_info.set(
1063 ShouldEnableQuicPersistServerInfo(command_line));
1064 globals_->enable_quic_port_selection.set(
1065 ShouldEnableQuicPortSelection(command_line));
1068 size_t max_packet_length = GetQuicMaxPacketLength(command_line,
1069 quic_trial_group);
1070 if (max_packet_length != 0) {
1071 globals_->quic_max_packet_length.set(max_packet_length);
1074 net::QuicVersion version = GetQuicVersion(command_line);
1075 if (version != net::QUIC_VERSION_UNSUPPORTED) {
1076 net::QuicVersionVector supported_versions;
1077 supported_versions.push_back(version);
1078 globals_->quic_supported_versions.set(supported_versions);
1081 if (command_line.HasSwitch(switches::kOriginToForceQuicOn)) {
1082 net::HostPortPair quic_origin =
1083 net::HostPortPair::FromString(
1084 command_line.GetSwitchValueASCII(switches::kOriginToForceQuicOn));
1085 if (!quic_origin.IsEmpty()) {
1086 globals_->origin_to_force_quic_on.set(quic_origin);
1091 bool IOThread::ShouldEnableQuic(const CommandLine& command_line,
1092 base::StringPiece quic_trial_group) {
1093 if (command_line.HasSwitch(switches::kDisableQuic))
1094 return false;
1096 if (command_line.HasSwitch(switches::kEnableQuic))
1097 return true;
1099 return quic_trial_group.starts_with(kQuicFieldTrialEnabledGroupName) ||
1100 quic_trial_group.starts_with(kQuicFieldTrialHttpsEnabledGroupName);
1103 bool IOThread::ShouldEnableQuicHttps(const CommandLine& command_line,
1104 base::StringPiece quic_trial_group) {
1105 if (command_line.HasSwitch(switches::kDisableQuicHttps))
1106 return false;
1108 if (command_line.HasSwitch(switches::kEnableQuicHttps))
1109 return true;
1111 return quic_trial_group.starts_with(kQuicFieldTrialHttpsEnabledGroupName);
1114 bool IOThread::ShouldEnableQuicPortSelection(
1115 const CommandLine& command_line) {
1116 if (command_line.HasSwitch(switches::kDisableQuicPortSelection))
1117 return false;
1119 if (command_line.HasSwitch(switches::kEnableQuicPortSelection))
1120 return true;
1122 #if defined(OS_WIN)
1123 chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
1124 // Avoid picking ports (which might induce a security dialog) when we have a
1125 // beta or stable release. Allow in all other cases, including when we do a
1126 // developer build (CHANNEL_UNKNOWN).
1127 if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
1128 channel == chrome::VersionInfo::CHANNEL_BETA) {
1129 // TODO(grt) bug=329255: Detect presence of rule on Windows that allows us
1130 // to do port selection without inducing a dialog.
1131 // When we have an API to see if the administrative security manager will
1132 // allow port selection without a security dialog, we may return true if
1133 // we're sure there will be no security dialog.
1134 return false;
1136 return true;
1137 #else
1138 return true;
1139 #endif
1142 bool IOThread::ShouldEnableQuicPacing(const CommandLine& command_line,
1143 base::StringPiece quic_trial_group) {
1144 if (command_line.HasSwitch(switches::kEnableQuicPacing))
1145 return true;
1147 if (command_line.HasSwitch(switches::kDisableQuicPacing))
1148 return false;
1150 return quic_trial_group.ends_with(kQuicFieldTrialPacingSuffix);
1153 bool IOThread::ShouldEnableQuicTimeBasedLossDetection(
1154 const CommandLine& command_line,
1155 base::StringPiece quic_trial_group) {
1156 if (command_line.HasSwitch(switches::kEnableQuicTimeBasedLossDetection))
1157 return true;
1159 if (command_line.HasSwitch(switches::kDisableQuicTimeBasedLossDetection))
1160 return false;
1162 return quic_trial_group.ends_with(
1163 kQuicFieldTrialTimeBasedLossDetectionSuffix);
1166 bool IOThread::ShouldEnableQuicPersistServerInfo(
1167 const CommandLine& command_line) {
1168 chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
1169 // Avoid persisting of Quic server config information to disk cache when we
1170 // have a beta or stable release. Allow in all other cases, including when we
1171 // do a developer build (CHANNEL_UNKNOWN).
1172 if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
1173 channel == chrome::VersionInfo::CHANNEL_BETA) {
1174 return false;
1176 return true;
1179 size_t IOThread::GetQuicMaxPacketLength(const CommandLine& command_line,
1180 base::StringPiece quic_trial_group) {
1181 if (command_line.HasSwitch(switches::kQuicMaxPacketLength)) {
1182 unsigned value;
1183 if (!base::StringToUint(
1184 command_line.GetSwitchValueASCII(switches::kQuicMaxPacketLength),
1185 &value)) {
1186 return 0;
1188 return value;
1191 // Format of the packet length group names is:
1192 // (Https)?Enabled<length>BytePackets.
1193 base::StringPiece length_str(quic_trial_group);
1194 if (length_str.starts_with(kQuicFieldTrialEnabledGroupName)) {
1195 length_str.remove_prefix(strlen(kQuicFieldTrialEnabledGroupName));
1196 } else if (length_str.starts_with(kQuicFieldTrialHttpsEnabledGroupName)) {
1197 length_str.remove_prefix(strlen(kQuicFieldTrialHttpsEnabledGroupName));
1198 } else {
1199 return 0;
1201 if (!length_str.ends_with(kQuicFieldTrialPacketLengthSuffix)) {
1202 return 0;
1204 length_str.remove_suffix(strlen(kQuicFieldTrialPacketLengthSuffix));
1205 unsigned value;
1206 if (!base::StringToUint(length_str, &value)) {
1207 return 0;
1209 return value;
1212 net::QuicVersion IOThread::GetQuicVersion(const CommandLine& command_line) {
1213 if (!command_line.HasSwitch(switches::kQuicVersion)) {
1214 return net::QUIC_VERSION_UNSUPPORTED;
1216 net::QuicVersionVector supported_versions = net::QuicSupportedVersions();
1217 std::string version_flag =
1218 command_line.GetSwitchValueASCII(switches::kQuicVersion);
1219 for (size_t i = 0; i < supported_versions.size(); ++i) {
1220 net::QuicVersion version = supported_versions[i];
1221 if (net::QuicVersionToString(version) == version_flag) {
1222 return version;
1225 return net::QUIC_VERSION_UNSUPPORTED;