url_request_context_config.cc | Explore in Territory

// Copyright 2014 The Chromium Authors
// 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 <type_traits>
#include <utility>

#include "base/containers/contains.h"
#include "base/json/json_reader.h"
#include "base/json/json_writer.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/task/sequenced_task_runner.h"
#include "base/values.h"
#include "build/build_config.h"
#include "components/cronet/stale_host_resolver.h"
#include "net/base/address_family.h"
#include "net/cert/caching_cert_verifier.h"
#include "net/cert/cert_verifier.h"
#include "net/cert/cert_verify_proc.h"
#include "net/cert/multi_threaded_cert_verifier.h"
#include "net/dns/context_host_resolver.h"
#include "net/dns/host_resolver.h"
#include "net/dns/mapped_host_resolver.h"
#include "net/http/http_network_session.h"
#include "net/http/http_server_properties.h"
#include "net/log/net_log.h"
#include "net/nqe/network_quality_estimator_params.h"
#include "net/quic/set_quic_flag.h"
#include "net/socket/ssl_client_socket.h"
#include "net/ssl/ssl_key_logger_impl.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_tag.h"
#include "net/url_request/url_request_context_builder.h"
#include "url/origin.h"

#if BUILDFLAG(ENABLE_REPORTING)
#include "net/reporting/reporting_policy.h"
#endif  // BUILDFLAG(ENABLE_REPORTING)

namespace cronet {

namespace {

// Name of disk cache directory.
const base::FilePath::CharType kDiskCacheDirectoryName[] = …);
const char kQuicFieldTrialName[] = …;
const char kQuicConnectionOptions[] = …;
const char kQuicClientConnectionOptions[] = …;
const char kQuicStoreServerConfigsInProperties[] = …;
const char kQuicMaxServerConfigsStoredInProperties[] = …;
const char kQuicIdleConnectionTimeoutSeconds[] = …;
const char kQuicMaxTimeBeforeCryptoHandshakeSeconds[] = …;
const char kQuicMaxIdleTimeBeforeCryptoHandshakeSeconds[] = …;
const char kQuicCloseSessionsOnIpChange[] = …;
const char kQuicGoAwaySessionsOnIpChange[] = …;
const char kQuicAllowServerMigration[] = …;
const char kQuicMigrateSessionsOnNetworkChangeV2[] = …;
const char kQuicMigrateIdleSessions[] = …;
const char kQuicRetransmittableOnWireTimeoutMilliseconds[] = …;
const char kQuicIdleSessionMigrationPeriodSeconds[] = …;
const char kQuicMaxTimeOnNonDefaultNetworkSeconds[] = …;
const char kQuicMaxMigrationsToNonDefaultNetworkOnWriteError[] = …;
const char kQuicMaxMigrationsToNonDefaultNetworkOnPathDegrading[] = …;
const char kQuicMigrateSessionsEarlyV2[] = …;
const char kQuicRetryOnAlternateNetworkBeforeHandshake[] = …;
const char kQuicHostWhitelist[] = …;
const char kQuicVersion[] = …;
const char kQuicFlags[] = …;
const char kRetryWithoutAltSvcOnQuicErrors[] = …;
const char kInitialDelayForBrokenAlternativeServiceSeconds[] = …;
const char kExponentialBackoffOnInitialDelay[] = …;
const char kDelayMainJobWithAvailableSpdySession[] = …;

// AsyncDNS experiment dictionary name.
const char kAsyncDnsFieldTrialName[] = …;
// Name of boolean to enable AsyncDNS experiment.
const char kAsyncDnsEnable[] = …;

// Stale DNS (StaleHostResolver) experiment dictionary name.
const char kStaleDnsFieldTrialName[] = …;
// Name of boolean to enable stale DNS experiment.
const char kStaleDnsEnable[] = …;
// Name of integer delay in milliseconds before a stale DNS result will be
// used.
const char kStaleDnsDelayMs[] = …;
// Name of integer maximum age (past expiration) in milliseconds of a stale DNS
// result that will be used, or 0 for no limit.
const char kStaleDnsMaxExpiredTimeMs[] = …;
// Name of integer maximum times each stale DNS result can be used, or 0 for no
// limit.
const char kStaleDnsMaxStaleUses[] = …;
// Name of boolean to allow stale DNS results from other networks to be used on
// the current network.
const char kStaleDnsAllowOtherNetwork[] = …;
// Name of boolean to enable persisting the DNS cache to disk.
const char kStaleDnsPersist[] = …;
// Name of integer minimum time in milliseconds between writes to disk for DNS
// cache persistence. Default value is one minute. Only relevant if
// "persist_to_disk" is true.
const char kStaleDnsPersistTimer[] = …;
// Name of boolean to allow use of stale DNS results when network resolver
// returns ERR_NAME_NOT_RESOLVED.
const char kStaleDnsUseStaleOnNameNotResolved[] = …;

// Rules to override DNS resolution. Intended for testing.
// See explanation of format in net/dns/mapped_host_resolver.h.
const char kHostResolverRulesFieldTrialName[] = …;
const char kHostResolverRules[] = …;

// NetworkQualityEstimator (NQE) experiment dictionary name.
const char kNetworkQualityEstimatorFieldTrialName[] = …;

// Network Error Logging experiment dictionary name.
const char kNetworkErrorLoggingFieldTrialName[] = …;
// Name of boolean to enable Reporting API.
const char kNetworkErrorLoggingEnable[] = …;
// Name of list of preloaded "Report-To" headers.
const char kNetworkErrorLoggingPreloadedReportToHeaders[] = …;
// Name of list of preloaded "NEL" headers.
const char kNetworkErrorLoggingPreloadedNELHeaders[] = …;
// Name of key (for above two lists) for header origin.
const char kNetworkErrorLoggingOrigin[] = …;
// Name of key (for above two lists) for header value.
const char kNetworkErrorLoggingValue[] = …;

// Disable IPv6 when on WiFi. This is a workaround for a known issue on certain
// Android phones, and should not be necessary when not on one of those devices.
// See https://crbug.com/696569 for details.
const char kDisableIPv6OnWifi[] = …;

const char kSSLKeyLogFile[] = …;

const char kAllowPortMigration[] = …;

const char kDisableTlsZeroRtt[] = …;

// Whether SPDY sessions should be closed or marked as going away upon relevant
// network changes. When not specified, /net behavior varies depending on the
// underlying OS.
const char kSpdyGoAwayOnIpChange[] = …;

// Whether the connection status of all bidirectional streams (created through
// the Cronet engine) should be monitored.
// The value must be an integer (> 0) and will be interpreted as a suggestion
// for the period of the heartbeat signal. See
// SpdySession#EnableBrokenConnectionDetection for more info.
const char kBidiStreamDetectBrokenConnection[] = …;

const char kUseDnsHttpsSvcbFieldTrialName[] = …;
const char kUseDnsHttpsSvcbUseAlpn[] = …;

// Serializes a base::Value into a string that can be used as the value of
// JFV-encoded HTTP header [1].  If |value| is a list, we remove the outermost
// [] delimiters from the result.
//
// [1] https://tools.ietf.org/html/draft-reschke-http-jfv
std::string SerializeJFVHeader(const base::Value& value) { … }

std::vector<URLRequestContextConfig::PreloadedNelAndReportingHeader>
ParseNetworkErrorLoggingHeaders(
    const base::Value::List& preloaded_headers_config) { … }

// Applies |f| to the value contained by |maybe|, returns empty optional
// otherwise.
template <typename T, typename F>
auto map(std::optional<T> maybe, F&& f) { … }

}  // namespace

URLRequestContextConfig::QuicHint::QuicHint(const std::string& host,
                                            int port,
                                            int alternate_port)
    : … { … }

URLRequestContextConfig::QuicHint::~QuicHint() { … }

URLRequestContextConfig::Pkp::Pkp(const std::string& host,
                                  bool include_subdomains,
                                  const base::Time& expiration_date)
    : … { … }

URLRequestContextConfig::Pkp::~Pkp() { … }

URLRequestContextConfig::PreloadedNelAndReportingHeader::
    PreloadedNelAndReportingHeader(const url::Origin& origin, std::string value)
    : … { … }

URLRequestContextConfig::PreloadedNelAndReportingHeader::
    ~PreloadedNelAndReportingHeader() = default;

URLRequestContextConfig::URLRequestContextConfig(
    bool enable_quic,
    bool enable_spdy,
    bool enable_brotli,
    HttpCacheType http_cache,
    int http_cache_max_size,
    bool load_disable_cache,
    const std::string& storage_path,
    const std::string& accept_language,
    const std::string& user_agent,
    base::Value::Dict experimental_options,
    std::unique_ptr<net::CertVerifier> mock_cert_verifier,
    bool enable_network_quality_estimator,
    bool bypass_public_key_pinning_for_local_trust_anchors,
    std::optional<int> network_thread_priority)
    : … { … }

URLRequestContextConfig::~URLRequestContextConfig() { … }

// static
std::unique_ptr<URLRequestContextConfig>
URLRequestContextConfig::CreateURLRequestContextConfig(
    bool enable_quic,
    bool enable_spdy,
    bool enable_brotli,
    HttpCacheType http_cache,
    int http_cache_max_size,
    bool load_disable_cache,
    const std::string& storage_path,
    const std::string& accept_language,
    const std::string& user_agent,
    const std::string& unparsed_experimental_options,
    std::unique_ptr<net::CertVerifier> mock_cert_verifier,
    bool enable_network_quality_estimator,
    bool bypass_public_key_pinning_for_local_trust_anchors,
    std::optional<int> network_thread_priority) { … }

// static
std::optional<base::Value::Dict>
URLRequestContextConfig::ParseExperimentalOptions(
    std::string unparsed_experimental_options) { … }

void URLRequestContextConfig::SetContextConfigExperimentalOptions() { … }

void URLRequestContextConfig::SetContextBuilderExperimentalOptions(
    net::URLRequestContextBuilder* context_builder,
    net::HttpNetworkSessionParams* session_params,
    net::QuicParams* quic_params,
    net::handles::NetworkHandle bound_network) { … }

void URLRequestContextConfig::ConfigureURLRequestContextBuilder(
    net::URLRequestContextBuilder* context_builder,
    net::handles::NetworkHandle bound_network) { … }

URLRequestContextConfigBuilder::URLRequestContextConfigBuilder() { … }
URLRequestContextConfigBuilder::~URLRequestContextConfigBuilder() { … }

std::unique_ptr<URLRequestContextConfig>
URLRequestContextConfigBuilder::Build() { … }

}  // namespace cronet
chromium/components/cronet/url_request_context_config.cc
