blob: 7dc243230a387409406590d06e9ea054e4d54ee4 [file] [log] [blame]
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/cronet/url_request_context_config.h"
#include <memory>
#include "base/bind.h"
#include "base/check.h"
#include "base/json/json_writer.h"
#include "base/notreached.h"
#include "base/strings/strcat.h"
#include "base/strings/string_piece.h"
#include "base/test/task_environment.h"
#include "base/test/values_test_util.h"
#include "base/values.h"
#include "build/build_config.h"
#include "net/base/host_port_pair.h"
#include "net/base/http_user_agent_settings.h"
#include "net/base/net_errors.h"
#include "net/base/network_isolation_key.h"
#include "net/cert/cert_verifier.h"
#include "net/dns/host_resolver.h"
#include "net/dns/host_resolver_manager.h"
#include "net/http/http_network_session.h"
#include "net/log/net_log_with_source.h"
#include "net/proxy_resolution/proxy_config.h"
#include "net/proxy_resolution/proxy_config_service_fixed.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_builder.h"
#include "testing/gtest/include/gtest/gtest.h"
#if BUILDFLAG(ENABLE_REPORTING)
#include "net/network_error_logging/network_error_logging_service.h"
#include "net/reporting/reporting_service.h"
#endif // BUILDFLAG(ENABLE_REPORTING)
namespace cronet {
namespace {
std::string WrapJsonHeader(base::StringPiece value) {
return base::StrCat({"[", value, "]"});
}
// Returns whether two JSON-encoded headers contain the same content, ignoring
// irrelevant encoding issues like whitespace and map element ordering.
bool JsonHeaderEquals(base::StringPiece expected, base::StringPiece actual) {
return base::test::ParseJson(WrapJsonHeader(expected)) ==
base::test::ParseJson(WrapJsonHeader(actual));
}
} // namespace
TEST(URLRequestContextConfigTest, TestExperimentalOptionParsing) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
// Create JSON for experimental options.
base::DictionaryValue options;
options.SetPath({"QUIC", "max_server_configs_stored_in_properties"},
base::Value(2));
options.SetPath({"QUIC", "user_agent_id"}, base::Value("Custom QUIC UAID"));
options.SetPath({"QUIC", "idle_connection_timeout_seconds"},
base::Value(300));
options.SetPath({"QUIC", "close_sessions_on_ip_change"}, base::Value(true));
options.SetPath({"QUIC", "connection_options"}, base::Value("TIME,TBBR,REJ"));
options.SetPath(
{"QUIC", "set_quic_flags"},
base::Value("FLAGS_quic_reloadable_flag_quic_testonly_default_false=true,"
"FLAGS_quic_restart_flag_quic_testonly_default_true=false"));
options.SetPath({"AsyncDNS", "enable"}, base::Value(true));
options.SetPath({"NetworkErrorLogging", "enable"}, base::Value(true));
options.SetPath({"NetworkErrorLogging", "preloaded_report_to_headers"},
base::test::ParseJson(R"json(
[
{
"origin": "https://test-origin/",
"value": {
"group": "test-group",
"max_age": 86400,
"endpoints": [
{"url": "https://test-endpoint/"},
],
},
},
{
"origin": "https://test-origin-2/",
"value": [
{
"group": "test-group-2",
"max_age": 86400,
"endpoints": [
{"url": "https://test-endpoint-2/"},
],
},
{
"group": "test-group-3",
"max_age": 86400,
"endpoints": [
{"url": "https://test-endpoint-3/"},
],
},
],
},
{
"origin": "https://value-is-missing/",
},
{
"value": "origin is missing",
},
{
"origin": 123,
"value": "origin is not a string",
},
{
"origin": "this is not a URL",
"value": "origin not a URL",
},
]
)json"));
options.SetPath({"NetworkErrorLogging", "preloaded_nel_headers"},
base::test::ParseJson(R"json(
[
{
"origin": "https://test-origin/",
"value": {
"report_to": "test-group",
"max_age": 86400,
},
},
]
)json"));
options.SetPath({"UnknownOption", "foo"}, base::Value(true));
options.SetPath({"HostResolverRules", "host_resolver_rules"},
base::Value("MAP * 127.0.0.1"));
// See http://crbug.com/696569.
options.SetKey("disable_ipv6_on_wifi", base::Value(true));
options.SetPath({"QUIC", "ios_network_service_type"}, base::Value(2));
std::string options_json;
EXPECT_TRUE(base::JSONWriter::Write(options, &options_json));
// Initialize QUIC flags set by the config.
FLAGS_quic_reloadable_flag_quic_testonly_default_false = false;
FLAGS_quic_restart_flag_quic_testonly_default_true = true;
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
options_json,
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>(42.0));
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
EXPECT_FALSE(config.effective_experimental_options->HasKey("UnknownOption"));
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
// Check Quic Connection options.
quic::QuicTagVector quic_connection_options;
quic_connection_options.push_back(quic::kTIME);
quic_connection_options.push_back(quic::kTBBR);
quic_connection_options.push_back(quic::kREJ);
EXPECT_EQ(quic_connection_options, quic_params->connection_options);
// Check QUIC flags.
EXPECT_TRUE(FLAGS_quic_reloadable_flag_quic_testonly_default_false);
EXPECT_FALSE(FLAGS_quic_restart_flag_quic_testonly_default_true);
// Check Custom QUIC User Agent Id.
EXPECT_EQ("Custom QUIC UAID", quic_params->user_agent_id);
// Check max_server_configs_stored_in_properties.
EXPECT_EQ(2u, quic_params->max_server_configs_stored_in_properties);
// Check idle_connection_timeout.
EXPECT_EQ(300, quic_params->idle_connection_timeout.InSeconds());
EXPECT_TRUE(quic_params->close_sessions_on_ip_change);
EXPECT_FALSE(quic_params->goaway_sessions_on_ip_change);
EXPECT_FALSE(quic_params->allow_server_migration);
EXPECT_FALSE(quic_params->migrate_sessions_on_network_change_v2);
EXPECT_FALSE(quic_params->migrate_sessions_early_v2);
EXPECT_FALSE(quic_params->migrate_idle_sessions);
EXPECT_FALSE(quic_params->retry_on_alternate_network_before_handshake);
EXPECT_FALSE(quic_params->race_stale_dns_on_connection);
EXPECT_FALSE(quic_params->go_away_on_path_degrading);
// Check network_service_type for iOS.
EXPECT_EQ(2, quic_params->ios_network_service_type);
#if defined(ENABLE_BUILT_IN_DNS)
// Check AsyncDNS resolver is enabled (not supported on iOS).
EXPECT_TRUE(context->host_resolver()->GetDnsConfigAsValue());
#endif // defined(ENABLE_BUILT_IN_DNS)
#if BUILDFLAG(ENABLE_REPORTING)
// Check Reporting and Network Error Logging are enabled (can be disabled at
// build time).
EXPECT_TRUE(context->reporting_service());
EXPECT_TRUE(context->network_error_logging_service());
#endif // BUILDFLAG(ENABLE_REPORTING)
ASSERT_EQ(2u, config.preloaded_report_to_headers.size());
EXPECT_EQ(url::Origin::CreateFromNormalizedTuple("https", "test-origin", 443),
config.preloaded_report_to_headers[0].origin);
EXPECT_TRUE(JsonHeaderEquals( //
R"json(
{
"group": "test-group",
"max_age": 86400,
"endpoints": [
{"url": "https://test-endpoint/"},
],
}
)json",
config.preloaded_report_to_headers[0].value));
EXPECT_EQ(
url::Origin::CreateFromNormalizedTuple("https", "test-origin-2", 443),
config.preloaded_report_to_headers[1].origin);
EXPECT_TRUE(JsonHeaderEquals( //
R"json(
{
"group": "test-group-2",
"max_age": 86400,
"endpoints": [
{"url": "https://test-endpoint-2/"},
],
},
{
"group": "test-group-3",
"max_age": 86400,
"endpoints": [
{"url": "https://test-endpoint-3/"},
],
}
)json",
config.preloaded_report_to_headers[1].value));
ASSERT_EQ(1u, config.preloaded_nel_headers.size());
EXPECT_EQ(url::Origin::CreateFromNormalizedTuple("https", "test-origin", 443),
config.preloaded_nel_headers[0].origin);
EXPECT_TRUE(JsonHeaderEquals( //
R"json(
{
"report_to": "test-group",
"max_age": 86400,
}
)json",
config.preloaded_nel_headers[0].value));
// Check IPv6 is disabled when on wifi.
EXPECT_FALSE(context->host_resolver()
->GetManagerForTesting()
->check_ipv6_on_wifi_for_testing());
// All host resolution expected to be mapped to an immediately-resolvable IP.
std::unique_ptr<net::HostResolver::ResolveHostRequest> resolve_request =
context->host_resolver()->CreateRequest(
net::HostPortPair("abcde", 80), net::NetworkIsolationKey(),
net::NetLogWithSource(), base::nullopt);
EXPECT_EQ(net::OK, resolve_request->Start(
base::BindOnce([](int error) { NOTREACHED(); })));
EXPECT_TRUE(config.network_thread_priority);
EXPECT_EQ(42.0, config.network_thread_priority.value());
}
TEST(URLRequestContextConfigTest, SetSupportedQuicVersion) {
// Note that this test covers the legacy mechanism which relies on
// QuicVersionToString. We should now be using ALPNs instead.
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
quic::ParsedQuicVersion version =
quic::AllSupportedVersionsWithQuicCrypto().front();
std::string experimental_options =
"{\"QUIC\":{\"quic_version\":\"" +
quic::QuicVersionToString(version.transport_version) + "\"}}";
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
experimental_options,
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_EQ(quic_params->supported_versions.size(), 1u);
EXPECT_EQ(quic_params->supported_versions[0], version);
}
TEST(URLRequestContextConfigTest, SetSupportedQuicVersionByAlpn) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
quic::ParsedQuicVersion version = quic::AllSupportedVersions().front();
std::string experimental_options =
"{\"QUIC\":{\"quic_version\":\"" + quic::AlpnForVersion(version) + "\"}}";
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
experimental_options,
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_EQ(quic_params->supported_versions.size(), 1u);
EXPECT_EQ(quic_params->supported_versions[0], version);
}
TEST(URLRequestContextConfigTest, SetUnsupportedQuicVersion) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{\"QUIC\":{\"quic_version\":\"h3-Q047\"}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_EQ(quic_params->supported_versions,
net::DefaultSupportedQuicVersions());
}
TEST(URLRequestContextConfigTest, SetObsoleteQuicVersion) {
// This test configures cronet with an obsolete QUIC version and validates
// that cronet ignores that version and uses the default versions.
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
std::string("{\"QUIC\":{\"quic_version\":\"") +
quic::AlpnForVersion(net::ObsoleteQuicVersions().back()) + "\"}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_EQ(quic_params->supported_versions,
net::DefaultSupportedQuicVersions());
}
TEST(URLRequestContextConfigTest, SetObsoleteQuicVersionWhenAllowed) {
// This test configures cronet with an obsolete QUIC version and explicitly
// allows it, then validates that cronet uses that version.
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
std::string("{\"QUIC\":{\"quic_version\":\"") +
quic::AlpnForVersion(net::ObsoleteQuicVersions().back()) +
"\",\"obsolete_versions_allowed\":true}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
quic::ParsedQuicVersionVector supported_versions = {
net::ObsoleteQuicVersions().back()};
EXPECT_EQ(quic_params->supported_versions, supported_versions);
}
TEST(URLRequestContextConfigTest, SetQuicServerMigrationOptions) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{\"QUIC\":{\"allow_server_migration\":true}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_FALSE(quic_params->close_sessions_on_ip_change);
EXPECT_TRUE(quic_params->allow_server_migration);
}
// Test that goaway_sessions_on_ip_change is set on by default for iOS.
#if defined(OS_IOS)
#define MAYBE_SetQuicGoAwaySessionsOnIPChangeByDefault \
SetQuicGoAwaySessionsOnIPChangeByDefault
#else
#define MAYBE_SetQuicGoAwaySessionsOnIPChangeByDefault \
DISABLED_SetQuicGoAwaySessionsOnIPChangeByDefault
#endif
TEST(URLRequestContextConfigTest,
MAYBE_SetQuicGoAwaySessionsOnIPChangeByDefault) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{\"QUIC\":{}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_FALSE(quic_params->close_sessions_on_ip_change);
EXPECT_TRUE(quic_params->goaway_sessions_on_ip_change);
}
// Tests that goaway_sessions_on_ip_changes can be set on via
// experimental options on non-iOS.
#if !defined(OS_IOS)
#define MAYBE_SetQuicGoAwaySessionsOnIPChangeViaExperimentOptions \
SetQuicGoAwaySessionsOnIPChangeViaExperimentOptions
#else
#define MAYBE_SetQuicGoAwaySessionsOnIPChangeViaExperimentOptions \
DISABLED_SetQuicGoAwaySessionsOnIPChangeViaExperimentOptions
#endif
TEST(URLRequestContextConfigTest,
MAYBE_SetQuicGoAwaySessionsOnIPChangeViaExperimentOptions) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{\"QUIC\":{\"goaway_sessions_on_ip_change\":true}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_FALSE(quic_params->close_sessions_on_ip_change);
EXPECT_TRUE(quic_params->goaway_sessions_on_ip_change);
}
// Test that goaway_sessions_on_ip_change can be set to false via
// exprimental options on iOS.
#if defined(OS_IOS)
#define MAYBE_DisableQuicGoAwaySessionsOnIPChangeViaExperimentOptions \
DisableQuicGoAwaySessionsOnIPChangeViaExperimentOptions
#else
#define MAYBE_DisableQuicGoAwaySessionsOnIPChangeViaExperimentOptions \
DISABLED_DisableQuicGoAwaySessionsOnIPChangeViaExperimentOptions
#endif
TEST(URLRequestContextConfigTest,
MAYBE_DisableQuicGoAwaySessionsOnIPChangeViaExperimentOptions) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{\"QUIC\":{\"goaway_sessions_on_ip_change\":false}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_FALSE(quic_params->close_sessions_on_ip_change);
EXPECT_FALSE(quic_params->goaway_sessions_on_ip_change);
}
TEST(URLRequestContextConfigTest, SetQuicConnectionMigrationV2Options) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
// Explicitly turn off "goaway_sessions_on_ip_change" which is default
// enabled on iOS but cannot be simultaneously set with migration option.
"{\"QUIC\":{\"migrate_sessions_on_network_change_v2\":true,"
"\"goaway_sessions_on_ip_change\":false,"
"\"migrate_sessions_early_v2\":true,"
"\"retry_on_alternate_network_before_handshake\":true,"
"\"migrate_idle_sessions\":true,"
"\"retransmittable_on_wire_timeout_milliseconds\":1000,"
"\"idle_session_migration_period_seconds\":15,"
"\"max_time_on_non_default_network_seconds\":10,"
"\"max_migrations_to_non_default_network_on_write_error\":3,"
"\"max_migrations_to_non_default_network_on_path_degrading\":4}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_TRUE(quic_params->migrate_sessions_on_network_change_v2);
EXPECT_TRUE(quic_params->migrate_sessions_early_v2);
EXPECT_TRUE(quic_params->retry_on_alternate_network_before_handshake);
EXPECT_EQ(1000,
quic_params->retransmittable_on_wire_timeout.InMilliseconds());
EXPECT_TRUE(quic_params->migrate_idle_sessions);
EXPECT_EQ(base::TimeDelta::FromSeconds(15),
quic_params->idle_session_migration_period);
EXPECT_EQ(base::TimeDelta::FromSeconds(10),
quic_params->max_time_on_non_default_network);
EXPECT_EQ(3,
quic_params->max_migrations_to_non_default_network_on_write_error);
EXPECT_EQ(
4, quic_params->max_migrations_to_non_default_network_on_path_degrading);
}
TEST(URLRequestContextConfigTest, SetQuicStaleDNSracing) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{\"QUIC\":{\"race_stale_dns_on_connection\":true}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_TRUE(quic_params->race_stale_dns_on_connection);
}
TEST(URLRequestContextConfigTest, SetQuicGoawayOnPathDegrading) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{\"QUIC\":{\"go_away_on_path_degrading\":true}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_TRUE(quic_params->go_away_on_path_degrading);
}
TEST(URLRequestContextConfigTest, SetQuicHostWhitelist) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{\"QUIC\":{\"host_whitelist\":\"www.example.com,www.example.org\"}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::HttpNetworkSession::Params* params =
context->GetNetworkSessionParams();
EXPECT_TRUE(base::Contains(params->quic_host_allowlist, "www.example.com"));
EXPECT_TRUE(base::Contains(params->quic_host_allowlist, "www.example.org"));
}
TEST(URLRequestContextConfigTest, SetQuicMaxTimeBeforeCryptoHandshake) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{\"QUIC\":{\"max_time_before_crypto_handshake_seconds\":7,"
"\"max_idle_time_before_crypto_handshake_seconds\":11}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
EXPECT_EQ(7, quic_params->max_time_before_crypto_handshake.InSeconds());
EXPECT_EQ(11, quic_params->max_idle_time_before_crypto_handshake.InSeconds());
}
TEST(URLURLRequestContextConfigTest, SetQuicConnectionOptions) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{\"QUIC\":{\"connection_options\":\"TIME,TBBR,REJ\","
"\"client_connection_options\":\"TBBR,1RTT\"}}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::QuicParams* quic_params = context->quic_context()->params();
quic::QuicTagVector connection_options;
connection_options.push_back(quic::kTIME);
connection_options.push_back(quic::kTBBR);
connection_options.push_back(quic::kREJ);
EXPECT_EQ(connection_options, quic_params->connection_options);
quic::QuicTagVector client_connection_options;
client_connection_options.push_back(quic::kTBBR);
client_connection_options.push_back(quic::k1RTT);
EXPECT_EQ(client_connection_options, quic_params->client_connection_options);
}
TEST(URLURLRequestContextConfigTest, SetAcceptLanguageAndUserAgent) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
true,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
EXPECT_EQ("foreign-language",
context->http_user_agent_settings()->GetAcceptLanguage());
EXPECT_EQ("fake agent", context->http_user_agent_settings()->GetUserAgent());
}
TEST(URLURLRequestContextConfigTest, TurningOffQuic) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfig config(
// Enable QUIC.
false,
// QUIC User Agent ID.
"Default QUIC User Agent ID",
// Enable SPDY.
true,
// Enable Brotli.
false,
// Type of http cache.
URLRequestContextConfig::HttpCacheType::DISK,
// Max size of http cache in bytes.
1024000,
// Disable caching for HTTP responses. Other information may be stored in
// the cache.
false,
// Storage path for http cache and cookie storage.
"/data/data/org.chromium.net/app_cronet_test/test_storage",
// Accept-Language request header field.
"foreign-language",
// User-Agent request header field.
"fake agent",
// JSON encoded experimental options.
"{}",
// MockCertVerifier to use for testing purposes.
std::unique_ptr<net::CertVerifier>(),
// Enable network quality estimator.
false,
// Enable Public Key Pinning bypass for local trust anchors.
true,
// Optional network thread priority.
base::Optional<double>());
net::URLRequestContextBuilder builder;
config.ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::HttpNetworkSession::Params* params =
context->GetNetworkSessionParams();
EXPECT_EQ(false, params->enable_quic);
}
TEST(URLURLRequestContextConfigTest, DefaultEnableQuic) {
base::test::TaskEnvironment task_environment_(
base::test::TaskEnvironment::MainThreadType::IO);
URLRequestContextConfigBuilder config_builder;
std::unique_ptr<URLRequestContextConfig> config = config_builder.Build();
net::URLRequestContextBuilder builder;
config->ConfigureURLRequestContextBuilder(&builder);
// Set a ProxyConfigService to avoid DCHECK failure when building.
builder.set_proxy_config_service(
std::make_unique<net::ProxyConfigServiceFixed>(
net::ProxyConfigWithAnnotation::CreateDirect()));
std::unique_ptr<net::URLRequestContext> context(builder.Build());
const net::HttpNetworkSession::Params* params =
context->GetNetworkSessionParams();
EXPECT_EQ(true, params->enable_quic);
}
// See stale_host_resolver_unittest.cc for test of StaleDNS options.
} // namespace cronet