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"
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"
91 #if !defined(USE_OPENSSL)
92 #include "net/cert/ct_log_verifier.h"
93 #include "net/cert/multi_log_ct_verifier.h"
96 #if defined(USE_NSS) || defined(OS_IOS)
97 #include "net/ocsp/nss_ocsp.h"
100 #if defined(OS_ANDROID) || defined(OS_IOS)
101 #include "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
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"
109 using content::BrowserThread
;
111 #if defined(OS_ANDROID) || defined(OS_IOS)
112 using data_reduction_proxy::DataReductionProxySettings
;
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.
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();
140 // Used for the "system" URLRequestContext.
141 class SystemURLRequestContext
: public net::URLRequestContext
{
143 SystemURLRequestContext() {
144 #if defined(USE_NSS) || defined(OS_IOS)
145 net::SetURLRequestContextForNSSHttpIO(this);
150 virtual ~SystemURLRequestContext() {
151 #if defined(USE_NSS) || defined(OS_IOS)
152 net::SetURLRequestContextForNSSHttpIO(NULL
);
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
)) {
166 command_line
.GetSwitchValueASCII(switches::kHostResolverParallelism
);
168 // Parse the switch (it should be a positive integer formatted as decimal).
170 if (base::StringToInt(s
, &n
) && n
> 0) {
171 options
.max_concurrent_resolves
= static_cast<size_t>(n
);
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
)) {
180 command_line
.GetSwitchValueASCII(switches::kHostResolverRetryAttempts
);
181 // Parse the switch (it should be a non-negative integer).
183 if (base::StringToInt(s
, &n
) && n
>= 0) {
184 options
.max_retry_attempts
= static_cast<size_t>(n
);
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
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());
274 int GetSwitchValueAsInt(const CommandLine
& command_line
,
275 const std::string
& switch_name
) {
277 if (!base::StringToInt(command_line
.GetSwitchValueASCII(switch_name
),
286 class IOThread::LoggingNetworkChangeObserver
287 : public net::NetworkChangeNotifier::IPAddressObserver
,
288 public net::NetworkChangeNotifier::ConnectionTypeObserver
,
289 public net::NetworkChangeNotifier::NetworkChangeObserver
{
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 "
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
));
340 net::NetLog
* net_log_
;
341 DISALLOW_COPY_AND_ASSIGN(LoggingNetworkChangeObserver
);
344 class SystemURLRequestContextGetter
: public net::URLRequestContextGetter
{
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
;
354 virtual ~SystemURLRequestContextGetter();
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(
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_
;
385 SystemRequestContextLeakChecker::SystemRequestContextLeakChecker(
387 : globals_(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.
411 PrefService
* local_state
,
412 policy::PolicyService
* policy_service
,
413 ChromeNetLog
* net_log
,
414 extensions::EventRouterForwarder
* extension_event_router_forwarder
)
416 extension_event_router_forwarder_(extension_event_router_forwarder
),
419 is_spdy_disabled_by_policy_(false),
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(
434 ChromeNetworkDelegate::InitializePrefsOnUIThread(
435 &system_enable_referrers_
,
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
,
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
,
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();
477 IOThread::Globals
* IOThread::globals() {
478 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO
));
482 void IOThread::SetGlobalsForTesting(Globals
* globals
) {
483 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO
));
484 DCHECK(!globals
|| !globals_
);
488 ChromeNetLog
* IOThread::net_log() {
492 void IOThread::ChangedToOnTheRecord() {
493 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI
));
494 BrowserThread::PostTask(
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
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();
522 const CommandLine
& command_line
= *CommandLine::ForCurrentProcess();
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.
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
563 net::MultiLogCTVerifier
* ct_verifier
= new net::MultiLogCTVerifier();
564 globals_
->cert_transparency_verifier
.reset(ct_verifier
);
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();
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());
597 if (command_line
.HasSwitch(switches::kCertificateTransparencyLog
)) {
598 LOG(DFATAL
) << "Certificate Transparency is not yet supported in Chrome "
599 "builds using OpenSSL.";
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(
677 new net::FtpProtocolHandler(
678 globals_
->proxy_script_fetcher_ftp_transaction_factory
.get()));
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
,
702 base::Bind(&ObserveKeychainEvents
));
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
,
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();
731 system_url_request_context_getter_
= NULL
;
733 // Release objects that the net::URLRequestContext could have been pointing
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();
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
);
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();
784 if (spdy_trial_group
== kSpdyFieldTrialDisabledGroupName
&&
785 !command_line
.HasSwitch(switches::kEnableWebSocketOverSpdy
)) {
786 net::HttpStreamFactory::set_spdy_enabled(false);
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
;
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
) {
856 if (base::StringToInt(value
, &streams
))
857 globals_
->initial_max_spdy_concurrent_streams
.set(streams
);
858 } else if (option
.empty() && it
== spdy_options
.begin()) {
861 LOG(DFATAL
) << "Unrecognized spdy option: " << option
;
867 void IOThread::RegisterPrefs(PrefRegistrySimple
* registry
) {
868 registry
->RegisterStringPref(prefs::kAuthSchemes
,
869 "basic,digest,ntlm,negotiate,"
871 registry
->RegisterBooleanPref(prefs::kDisableAuthNegotiateCnameLookup
, false);
872 registry
->RegisterBooleanPref(prefs::kEnableAuthNegotiatePort
, false);
873 registry
->RegisterStringPref(prefs::kAuthServerWhitelist
, std::string());
874 registry
->RegisterStringPref(prefs::kAuthNegotiateDelegateWhitelist
,
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(
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();
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 ¶ms
->spdy_initial_max_concurrent_streams
);
947 globals_
->force_spdy_single_domain
.CopyToIfSet(
948 ¶ms
->force_spdy_single_domain
);
949 globals_
->enable_spdy_compression
.CopyToIfSet(
950 ¶ms
->enable_spdy_compression
);
951 globals_
->enable_spdy_ping_based_connection_checking
.CopyToIfSet(
952 ¶ms
->enable_spdy_ping_based_connection_checking
);
953 globals_
->spdy_default_protocol
.CopyToIfSet(
954 ¶ms
->spdy_default_protocol
);
955 globals_
->trusted_spdy_proxy
.CopyToIfSet(
956 ¶ms
->trusted_spdy_proxy
);
957 globals_
->enable_quic
.CopyToIfSet(¶ms
->enable_quic
);
958 globals_
->enable_quic_https
.CopyToIfSet(¶ms
->enable_quic_https
);
959 globals_
->enable_quic_pacing
.CopyToIfSet(
960 ¶ms
->enable_quic_pacing
);
961 globals_
->enable_quic_time_based_loss_detection
.CopyToIfSet(
962 ¶ms
->enable_quic_time_based_loss_detection
);
963 globals_
->enable_quic_persist_server_info
.CopyToIfSet(
964 ¶ms
->enable_quic_persist_server_info
);
965 globals_
->enable_quic_port_selection
.CopyToIfSet(
966 ¶ms
->enable_quic_port_selection
);
967 globals_
->quic_max_packet_length
.CopyToIfSet(¶ms
->quic_max_packet_length
);
968 globals_
->quic_supported_versions
.CopyToIfSet(
969 ¶ms
->quic_supported_versions
);
970 globals_
->origin_to_force_quic_on
.CopyToIfSet(
971 ¶ms
->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.
992 void IOThread::InitSystemRequestContext() {
993 if (system_url_request_context_getter_
.get())
995 // If we're in unit_tests, IOThread may not be run.
996 if (!BrowserThread::IsMessageLoopValid(BrowserThread::IO
))
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(
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(
1021 globals_
->proxy_script_fetcher_context
.get(),
1022 globals_
->system_network_delegate
.get(),
1023 system_proxy_config_service_
.release(),
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
);
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
,
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
))
1096 if (command_line
.HasSwitch(switches::kEnableQuic
))
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
))
1108 if (command_line
.HasSwitch(switches::kEnableQuicHttps
))
1111 return quic_trial_group
.starts_with(kQuicFieldTrialHttpsEnabledGroupName
);
1114 bool IOThread::ShouldEnableQuicPortSelection(
1115 const CommandLine
& command_line
) {
1116 if (command_line
.HasSwitch(switches::kDisableQuicPortSelection
))
1119 if (command_line
.HasSwitch(switches::kEnableQuicPortSelection
))
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.
1142 bool IOThread::ShouldEnableQuicPacing(const CommandLine
& command_line
,
1143 base::StringPiece quic_trial_group
) {
1144 if (command_line
.HasSwitch(switches::kEnableQuicPacing
))
1147 if (command_line
.HasSwitch(switches::kDisableQuicPacing
))
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
))
1159 if (command_line
.HasSwitch(switches::kDisableQuicTimeBasedLossDetection
))
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
) {
1179 size_t IOThread::GetQuicMaxPacketLength(const CommandLine
& command_line
,
1180 base::StringPiece quic_trial_group
) {
1181 if (command_line
.HasSwitch(switches::kQuicMaxPacketLength
)) {
1183 if (!base::StringToUint(
1184 command_line
.GetSwitchValueASCII(switches::kQuicMaxPacketLength
),
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
));
1201 if (!length_str
.ends_with(kQuicFieldTrialPacketLengthSuffix
)) {
1204 length_str
.remove_suffix(strlen(kQuicFieldTrialPacketLengthSuffix
));
1206 if (!base::StringToUint(length_str
, &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
) {
1225 return net::QUIC_VERSION_UNSUPPORTED
;