if (command_line.HasSwitch(switches::kSSLKeyLogFile)) {

base::FilePath path =

command_line.GetSwitchValuePath(switches::kSSLKeyLogFile);

if (!path.empty())

return path;

LOG(WARNING) << "ssl-key-log-file argument missing";

}

std::unique_ptr<base::Environment> env(base::Environment::Create());

std::string path_str;

env->GetVar("SSLKEYLOGFILE", &path_str);

#if defined(OS_WIN)

// base::Environment returns environment variables in UTF-8 on Windows.

return base::FilePath(base::UTF8ToUTF16(path_str));

#else

return base::FilePath(path_str);

#endif

public:

SystemURLRequestContext() {

#if defined(USE_NSS_CERTS)

net::SetURLRequestContextForNSSHttpIO(this);

#endif

}

private:

~SystemURLRequestContext() override {

AssertNoURLRequests();

#if defined(USE_NSS_CERTS)

net::SetURLRequestContextForNSSHttpIO(NULL);

#endif

}

net::NetLog* net_log) {

TRACE_EVENT0("startup", "IOThread::CreateGlobalHostResolver");

const base::CommandLine& command_line =

*base::CommandLine::ForCurrentProcess();

net::HostResolver::Options options;

// Use the retry attempts override from the command-line, if any.

if (command_line.HasSwitch(switches::kHostResolverRetryAttempts)) {

std::string s =

command_line.GetSwitchValueASCII(switches::kHostResolverRetryAttempts);

// Parse the switch (it should be a non-negative integer).

int n;

if (base::StringToInt(s, &n) && n >= 0) {

options.max_retry_attempts = static_cast<size_t>(n);

} else {

LOG(ERROR) << "Invalid switch for host resolver retry attempts: " << s;

}

}

std::unique_ptr<net::HostResolver> global_host_resolver;

#if defined OS_CHROMEOS

global_host_resolver =

chromeos::HostResolverImplChromeOS::CreateSystemResolver(options,

net_log);

#else

global_host_resolver =

net::HostResolver::CreateSystemResolver(options, net_log);

#endif

// If hostname remappings were specified on the command-line, layer these

// rules on top of the real host resolver. This allows forwarding all requests

// through a designated test server.

if (!command_line.HasSwitch(switches::kHostResolverRules))

return global_host_resolver;

std::unique_ptr<net::MappedHostResolver> remapped_resolver(

new net::MappedHostResolver(std::move(global_host_resolver)));

remapped_resolver->SetRulesFromString(

command_line.GetSwitchValueASCII(switches::kHostResolverRules));

return std::move(remapped_resolver);

const std::string& switch_name) {

int value;

if (!base::StringToInt(command_line.GetSwitchValueASCII(switch_name),

&value)) {

return 0;

}

return value;

: net_log_(net_log) {

net::NetworkChangeNotifier::AddIPAddressObserver(this);

net::NetworkChangeNotifier::AddConnectionTypeObserver(this);

net::NetworkChangeNotifier::AddNetworkChangeObserver(this);

VLOG(1) << "Observed a change to the network IP addresses";

net_log_->AddGlobalEntry(net::NetLog::TYPE_NETWORK_IP_ADDRESSES_CHANGED);

net::NetworkChangeNotifier::ConnectionType type) override {

std::string type_as_string =

net::NetworkChangeNotifier::ConnectionTypeToString(type);

VLOG(1) << "Observed a change to network connectivity state "

<< type_as_string;

net_log_->AddGlobalEntry(

net::NetLog::TYPE_NETWORK_CONNECTIVITY_CHANGED,

net::NetLog::StringCallback("new_connection_type", &type_as_string));

net::NetworkChangeNotifier::ConnectionType type) override {

std::string type_as_string =

net::NetworkChangeNotifier::ConnectionTypeToString(type);

VLOG(1) << "Observed a network change to state " << type_as_string;

net_log_->AddGlobalEntry(

net::NetLog::TYPE_NETWORK_CHANGED,

net::NetLog::StringCallback("new_connection_type", &type_as_string));

public:

explicit SystemURLRequestContextGetter(IOThread* io_thread);

// Implementation for net::UrlRequestContextGetter.

net::URLRequestContext* GetURLRequestContext() override;

scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()

const override;

protected:

~SystemURLRequestContextGetter() override;

private:

IOThread* const io_thread_; // Weak pointer, owned by BrowserProcess.

scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;

base::debug::LeakTracker<SystemURLRequestContextGetter> leak_tracker_;

IOThread* io_thread)

: io_thread_(io_thread),

network_task_runner_(

BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)) {

PrefService* local_state,

policy::PolicyService* policy_service,

net_log::ChromeNetLog* net_log,

extensions::EventRouterForwarder* extension_event_router_forwarder)

: net_log_(net_log),

#if defined(ENABLE_EXTENSIONS)

extension_event_router_forwarder_(extension_event_router_forwarder),

#endif

globals_(NULL),

is_spdy_allowed_by_policy_(true),

is_quic_allowed_by_policy_(true),

creation_time_(base::TimeTicks::Now()),

weak_factory_(this) {

scoped_refptr<base::SingleThreadTaskRunner> io_thread_proxy =

BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);

auth_schemes_ = local_state->GetString(prefs::kAuthSchemes);

negotiate_disable_cname_lookup_.Init(

prefs::kDisableAuthNegotiateCnameLookup, local_state,

base::Bind(&IOThread::UpdateNegotiateDisableCnameLookup,

base::Unretained(this)));

negotiate_disable_cname_lookup_.MoveToThread(io_thread_proxy);

negotiate_enable_port_.Init(

prefs::kEnableAuthNegotiatePort, local_state,

base::Bind(&IOThread::UpdateNegotiateEnablePort, base::Unretained(this)));

negotiate_enable_port_.MoveToThread(io_thread_proxy);

auth_server_whitelist_.Init(

prefs::kAuthServerWhitelist, local_state,

base::Bind(&IOThread::UpdateServerWhitelist, base::Unretained(this)));

auth_server_whitelist_.MoveToThread(io_thread_proxy);

auth_delegate_whitelist_.Init(

prefs::kAuthNegotiateDelegateWhitelist, local_state,

base::Bind(&IOThread::UpdateDelegateWhitelist, base::Unretained(this)));

auth_delegate_whitelist_.MoveToThread(io_thread_proxy);

#if defined(OS_ANDROID)

auth_android_negotiate_account_type_.Init(

prefs::kAuthAndroidNegotiateAccountType, local_state,

base::Bind(&IOThread::UpdateAndroidAuthNegotiateAccountType,

base::Unretained(this)));

auth_android_negotiate_account_type_.MoveToThread(io_thread_proxy);

#endif

#if defined(OS_POSIX) && !defined(OS_ANDROID)

gssapi_library_name_ = local_state->GetString(prefs::kGSSAPILibraryName);

#endif

pref_proxy_config_tracker_.reset(

ProxyServiceFactory::CreatePrefProxyConfigTrackerOfLocalState(

local_state));

ChromeNetworkDelegate::InitializePrefsOnUIThread(

&system_enable_referrers_,

NULL,

NULL,

NULL,

local_state);

ssl_config_service_manager_.reset(

ssl_config::SSLConfigServiceManager::CreateDefaultManager(

local_state,

BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)));

base::Value* dns_client_enabled_default = new base::FundamentalValue(

chrome_browser_net::ConfigureAsyncDnsFieldTrial());

local_state->SetDefaultPrefValue(prefs::kBuiltInDnsClientEnabled,

dns_client_enabled_default);

chrome_browser_net::LogAsyncDnsPrefSource(

local_state->FindPreference(prefs::kBuiltInDnsClientEnabled));

dns_client_enabled_.Init(prefs::kBuiltInDnsClientEnabled,

local_state,

base::Bind(&IOThread::UpdateDnsClientEnabled,

base::Unretained(this)));

dns_client_enabled_.MoveToThread(io_thread_proxy);

quick_check_enabled_.Init(prefs::kQuickCheckEnabled,

local_state);

quick_check_enabled_.MoveToThread(io_thread_proxy);

is_spdy_allowed_by_policy_ =

policy_service

->GetPolicies(policy::PolicyNamespace(policy::POLICY_DOMAIN_CHROME,

std::string()))

.Get(policy::key::kDisableSpdy) == nullptr;

const base::Value* value = policy_service->GetPolicies(

policy::PolicyNamespace(policy::POLICY_DOMAIN_CHROME,

std::string())).GetValue(policy::key::kQuicAllowed);

if (value)

value->GetAsBoolean(&is_quic_allowed_by_policy_);

// Some unit tests use IOThread but do not initialize MetricsService. In that

// case it is fine not to have |metrics_data_use_forwarder_|.

if (g_browser_process->metrics_service()) {

// Callback for updating data use prefs should be obtained on UI thread.

metrics_data_use_forwarder_ =

g_browser_process->metrics_service()->GetDataUseForwardingCallback();

}

BrowserThread::SetDelegate(BrowserThread::IO, this);

DCHECK_CURRENTLY_ON(BrowserThread::IO);

DCHECK(!globals || !globals_);

globals_ = globals;

DCHECK_CURRENTLY_ON(BrowserThread::UI);

BrowserThread::PostTask(

BrowserThread::IO,

FROM_HERE,

base::Bind(&IOThread::ChangedToOnTheRecordOnIOThread,

base::Unretained(this)));

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile1(

FROM_HERE_WITH_EXPLICIT_FUNCTION("466432 IOThread::InitAsync::Start"));

TRACE_EVENT0("startup", "IOThread::InitAsync");

DCHECK_CURRENTLY_ON(BrowserThread::IO);

#if defined(USE_NSS_CERTS)

net::SetMessageLoopForNSSHttpIO();

#endif

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile2(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CommandLineForCurrentProcess"));

const base::CommandLine& command_line =

*base::CommandLine::ForCurrentProcess();

// Export ssl keys if log file specified.

base::FilePath ssl_keylog_file = GetSSLKeyLogFile(command_line);

if (!ssl_keylog_file.empty()) {

net::SSLClientSocket::SetSSLKeyLogFile(

ssl_keylog_file,

BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));

}

DCHECK(!globals_);

globals_ = new Globals;

// Add an observer that will emit network change events to the ChromeNetLog.

// Assuming NetworkChangeNotifier dispatches in FIFO order, we should be

// logging the network change before other IO thread consumers respond to it.

network_change_observer_.reset(

new LoggingNetworkChangeObserver(net_log_));

// Setup the HistogramWatcher to run on the IO thread.

net::NetworkChangeNotifier::InitHistogramWatcher();

#if defined(ENABLE_EXTENSIONS)

globals_->extension_event_router_forwarder =

extension_event_router_forwarder_;

#endif

std::unique_ptr<data_usage::DataUseAmortizer> data_use_amortizer;

#if BUILDFLAG(ANDROID_JAVA_UI)

data_use_amortizer.reset(new data_usage::android::TrafficStatsAmortizer());

#endif

globals_->data_use_aggregator.reset(new data_usage::DataUseAggregator(

std::unique_ptr<data_usage::DataUseAnnotator>(

new chrome_browser_data_usage::TabIdAnnotator()),

std::move(data_use_amortizer)));

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile3(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::ChromeNetworkDelegate"));

std::unique_ptr<ChromeNetworkDelegate> chrome_network_delegate(

new ChromeNetworkDelegate(extension_event_router_forwarder(),

&system_enable_referrers_,

metrics_data_use_forwarder_));

// By default, data usage is considered off the record.

chrome_network_delegate->set_data_use_aggregator(

globals_->data_use_aggregator.get(),

true /* is_data_usage_off_the_record */);

#if BUILDFLAG(ANDROID_JAVA_UI)

globals_->external_data_use_observer.reset(

new chrome::android::ExternalDataUseObserver(

globals_->data_use_aggregator.get(),

BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),

BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)));

#endif

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile4(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CreateGlobalHostResolver"));

globals_->system_network_delegate = std::move(chrome_network_delegate);

globals_->host_resolver = CreateGlobalHostResolver(net_log_);

std::map<std::string, std::string> network_quality_estimator_params;

variations::GetVariationParams(kNetworkQualityEstimatorFieldTrialName,

&network_quality_estimator_params);

std::unique_ptr<net::ExternalEstimateProvider> external_estimate_provider;

#if BUILDFLAG(ANDROID_JAVA_UI)

external_estimate_provider.reset(

new chrome::android::ExternalEstimateProviderAndroid());

#endif

// Pass ownership.

globals_->network_quality_estimator.reset(new net::NetworkQualityEstimator(

std::move(external_estimate_provider), network_quality_estimator_params));

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile5(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::UpdateDnsClientEnabled::Start"));

UpdateDnsClientEnabled();

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile6(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::UpdateDnsClientEnabled::End"));

#if defined(OS_CHROMEOS)

// Creates a CertVerifyProc that doesn't allow any profile-provided certs.

globals_->cert_verifier.reset(new net::MultiThreadedCertVerifier(

new chromeos::CertVerifyProcChromeOS()));

#else

globals_->cert_verifier.reset(new net::MultiThreadedCertVerifier(

net::CertVerifyProc::CreateDefault()));

#endif

globals_->transport_security_state.reset(new net::TransportSecurityState());

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile8(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CreateLogVerifiers::Start"));

std::vector<scoped_refptr<const net::CTLogVerifier>> ct_logs(

net::ct::CreateLogVerifiersForKnownLogs());

// Add logs from command line

if (command_line.HasSwitch(switches::kCertificateTransparencyLog)) {

std::string switch_value = command_line.GetSwitchValueASCII(

switches::kCertificateTransparencyLog);

for (const base::StringPiece& curr_log : base::SplitStringPiece(

switch_value, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {

std::vector<std::string> log_metadata = base::SplitString(

curr_log, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);

CHECK_GE(log_metadata.size(), 3u)

<< "CT log metadata missing: Switch format is "

<< "'description:base64_key:url_without_schema'.";

std::string log_description(log_metadata[0]);

std::string log_url(std::string("https://") + log_metadata[2]);

std::string ct_public_key_data;

CHECK(base::Base64Decode(log_metadata[1], &ct_public_key_data))

<< "Unable to decode CT public key.";

scoped_refptr<const net::CTLogVerifier> external_log_verifier(

net::CTLogVerifier::Create(ct_public_key_data, log_description,

log_url));

CHECK(external_log_verifier) << "Unable to parse CT public key.";

VLOG(1) << "Adding log with description " << log_description;

ct_logs.push_back(external_log_verifier);

}

}

globals_->ct_logs.assign(ct_logs.begin(), ct_logs.end());

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile9(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CreateLogVerifiers::End"));

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile7(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CreateMultiLogVerifier"));

net::MultiLogCTVerifier* ct_verifier = new net::MultiLogCTVerifier();

globals_->cert_transparency_verifier.reset(ct_verifier);

// Add built-in logs

ct_verifier->AddLogs(globals_->ct_logs);

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile10(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CTPolicyEnforcer"));

globals_->ct_policy_enforcer.reset(new net::CTPolicyEnforcer());

params_.ct_policy_enforcer = globals_->ct_policy_enforcer.get();

globals_->ssl_config_service = GetSSLConfigService();

CreateDefaultAuthHandlerFactory();

globals_->http_server_properties.reset(new net::HttpServerPropertiesImpl());

// For the ProxyScriptFetcher, we use a direct ProxyService.

globals_->proxy_script_fetcher_proxy_service =

net::ProxyService::CreateDirectWithNetLog(net_log_);

// In-memory cookie store.

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile11(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CreateCookieStore::Start"));

globals_->system_cookie_store =

content::CreateCookieStore(content::CookieStoreConfig());

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile12(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CreateCookieStore::End"));

// In-memory channel ID store.

globals_->system_channel_id_service.reset(

new net::ChannelIDService(

new net::DefaultChannelIDStore(NULL),

base::WorkerPool::GetTaskRunner(true)));

globals_->system_cookie_store->SetChannelIDServiceID(

globals_->system_channel_id_service->GetUniqueID());

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile12_1(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CreateDnsProbeService"));

globals_->dns_probe_service.reset(new chrome_browser_net::DnsProbeService());

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile12_2(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CreateHostMappingRules"));

globals_->host_mapping_rules.reset(new net::HostMappingRules());

params_.host_mapping_rules = globals_->host_mapping_rules.get();

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile12_3(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CreateHTTPUserAgentSettings"));

globals_->http_user_agent_settings.reset(

new net::StaticHttpUserAgentSettings(std::string(), GetUserAgent()));

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile12_4(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::CommandLineConfiguration"));

if (command_line.HasSwitch(switches::kHostRules)) {

TRACE_EVENT_BEGIN0("startup", "IOThread::InitAsync:SetRulesFromString");

globals_->host_mapping_rules->SetRulesFromString(

command_line.GetSwitchValueASCII(switches::kHostRules));

TRACE_EVENT_END0("startup", "IOThread::InitAsync:SetRulesFromString");

}

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile12_5(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::QuicConfiguration"));

if (command_line.HasSwitch(

switches::kEnableUserAlternateProtocolPorts)) {

params_.enable_user_alternate_protocol_ports = true;

}

globals_->enable_brotli =

base::FeatureList::IsEnabled(features::kBrotliEncoding);

params_.enable_token_binding =

base::FeatureList::IsEnabled(features::kTokenBinding);

// TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466432

// is fixed.

tracked_objects::ScopedTracker tracking_profile13(

FROM_HERE_WITH_EXPLICIT_FUNCTION(

"466432 IOThread::InitAsync::InitializeNetworkOptions"));

// TODO(rch): Make the client socket factory a per-network session instance,

// constructed from a NetworkSession::Params, to allow us to move this option

// to IOThread::Globals & HttpNetworkSession::Params.

network_session_configurator_.ParseFieldTrialsAndCommandLine(

is_spdy_allowed_by_policy_, is_quic_allowed_by_policy_, &params_);

bool always_enable_tfo_if_supported =

command_line.HasSwitch(switches::kEnableTcpFastOpen);

// Check for OS support of TCP FastOpen, and turn it on for all connections if

// indicated by user.

net::CheckSupportAndMaybeEnableTCPFastOpen(always_enable_tfo_if_supported);

TRACE_EVENT_BEGIN0("startup",

"IOThread::Init:ProxyScriptFetcherRequestContext");

globals_->proxy_script_fetcher_context.reset(

ConstructProxyScriptFetcherContext(globals_, params_, net_log_));

TRACE_EVENT_END0("startup",

"IOThread::Init:ProxyScriptFetcherRequestContext");

const version_info::Channel channel = chrome::GetChannel();

if (channel == version_info::Channel::UNKNOWN ||

channel == version_info::Channel::CANARY ||

channel == version_info::Channel::DEV) {

globals_->url_request_backoff_manager.reset(

new net::URLRequestBackoffManager());

}

#if defined(OS_MACOSX)

// Start observing Keychain events. This needs to be done on the UI thread,

// as Keychain services requires a CFRunLoop.

BrowserThread::PostTask(BrowserThread::UI,

FROM_HERE,

base::Bind(&ObserveKeychainEvents));

#endif

// InitSystemRequestContext turns right around and posts a task back

// to the IO thread, so we can't let it run until we know the IO

// thread has started.

//

// Note that since we are at BrowserThread::Init time, the UI thread

// is blocked waiting for the thread to start. Therefore, posting

// this task to the main thread's message loop here is guaranteed to

// get it onto the message loop while the IOThread object still

// exists. However, the message might not be processed on the UI

// thread until after IOThread is gone, so use a weak pointer.

BrowserThread::PostTask(BrowserThread::UI,

FROM_HERE,

base::Bind(&IOThread::InitSystemRequestContext,

weak_factory_.GetWeakPtr()));

#if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)

// Record how common CPUs with broken NEON units are. See

// https://crbug.com/341598.

crypto::EnsureOpenSSLInit();

UMA_HISTOGRAM_BOOLEAN("Net.HasBrokenNEON", CRYPTO_has_broken_NEON());

#endif

base::debug::LeakTracker<SafeBrowsingURLRequestContext>::CheckForLeaks();

#if defined(USE_NSS_CERTS)

net::ShutdownNSSHttpIO();

#endif

system_url_request_context_getter_ = NULL;

// Release objects that the net::URLRequestContext could have been pointing

// to.

// Shutdown the HistogramWatcher on the IO thread.

net::NetworkChangeNotifier::ShutdownHistogramWatcher();

// This must be reset before the ChromeNetLog is destroyed.

network_change_observer_.reset();

system_proxy_config_service_.reset();

delete globals_;

globals_ = NULL;

base::debug::LeakTracker<SystemURLRequestContextGetter>::CheckForLeaks();