chromium/net/url_request/url_request_unittest.cc

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
#pragma allow_unsafe_buffers
#endif

#include "net/url_request/url_request.h"

#include <stdint.h>

#include <algorithm>
#include <iterator>
#include <limits>
#include <memory>
#include <optional>
#include <string_view>
#include <utility>

#include "base/base64.h"
#include "base/base64url.h"
#include "base/compiler_specific.h"
#include "base/containers/heap_array.h"
#include "base/containers/span.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/format_macros.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/location.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/path_service.h"
#include "base/ranges/algorithm.h"
#include "base/run_loop.h"
#include "base/strings/escape.h"
#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/task/single_thread_task_runner.h"
#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/test_future.h"
#include "base/test/values_test_util.h"
#include "base/time/time.h"
#include "base/values.h"
#include "build/build_config.h"
#include "build/buildflag.h"
#include "crypto/sha2.h"
#include "net/base/chunked_upload_data_stream.h"
#include "net/base/directory_listing.h"
#include "net/base/elements_upload_data_stream.h"
#include "net/base/features.h"
#include "net/base/hash_value.h"
#include "net/base/ip_address.h"
#include "net/base/ip_endpoint.h"
#include "net/base/isolation_info.h"
#include "net/base/load_flags.h"
#include "net/base/load_timing_info.h"
#include "net/base/load_timing_info_test_util.h"
#include "net/base/net_errors.h"
#include "net/base/net_module.h"
#include "net/base/proxy_chain.h"
#include "net/base/proxy_server.h"
#include "net/base/proxy_string_util.h"
#include "net/base/request_priority.h"
#include "net/base/test_completion_callback.h"
#include "net/base/transport_info.h"
#include "net/base/upload_bytes_element_reader.h"
#include "net/base/upload_data_stream.h"
#include "net/base/upload_file_element_reader.h"
#include "net/base/url_util.h"
#include "net/cert/asn1_util.h"
#include "net/cert/caching_cert_verifier.h"
#include "net/cert/cert_net_fetcher.h"
#include "net/cert/cert_verifier.h"
#include "net/cert/coalescing_cert_verifier.h"
#include "net/cert/crl_set.h"
#include "net/cert/do_nothing_ct_verifier.h"
#include "net/cert/ev_root_ca_metadata.h"
#include "net/cert/mock_cert_verifier.h"
#include "net/cert/multi_log_ct_verifier.h"
#include "net/cert/signed_certificate_timestamp_and_status.h"
#include "net/cert/test_root_certs.h"
#include "net/cert/x509_util.h"
#include "net/cert_net/cert_net_fetcher_url_request.h"
#include "net/cookies/canonical_cookie_test_helpers.h"
#include "net/cookies/cookie_inclusion_status.h"
#include "net/cookies/cookie_monster.h"
#include "net/cookies/cookie_setting_override.h"
#include "net/cookies/cookie_store_test_helpers.h"
#include "net/cookies/cookie_util.h"
#include "net/cookies/test_cookie_access_delegate.h"
#include "net/disk_cache/disk_cache.h"
#include "net/dns/mock_host_resolver.h"
#include "net/dns/public/host_resolver_results.h"
#include "net/dns/public/secure_dns_policy.h"
#include "net/http/http_byte_range.h"
#include "net/http/http_cache.h"
#include "net/http/http_connection_info.h"
#include "net/http/http_network_layer.h"
#include "net/http/http_network_session.h"
#include "net/http/http_request_headers.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_server_properties.h"
#include "net/http/http_status_code.h"
#include "net/http/http_transaction_test_util.h"
#include "net/http/http_util.h"
#include "net/http/transport_security_state.h"
#include "net/http/transport_security_state_source.h"
#include "net/log/file_net_log_observer.h"
#include "net/log/net_log.h"
#include "net/log/net_log_event_type.h"
#include "net/log/net_log_source.h"
#include "net/log/test_net_log.h"
#include "net/log/test_net_log_util.h"
#include "net/net_buildflags.h"
#include "net/proxy_resolution/configured_proxy_resolution_service.h"
#include "net/quic/mock_crypto_client_stream_factory.h"
#include "net/quic/quic_server_info.h"
#include "net/socket/read_buffering_stream_socket.h"
#include "net/socket/socket_test_util.h"
#include "net/socket/ssl_client_socket.h"
#include "net/ssl/client_cert_identity_test_util.h"
#include "net/ssl/ssl_connection_status_flags.h"
#include "net/ssl/ssl_private_key.h"
#include "net/ssl/ssl_server_config.h"
#include "net/ssl/test_ssl_config_service.h"
#include "net/storage_access_api/status.h"
#include "net/test/cert_test_util.h"
#include "net/test/embedded_test_server/http_request.h"
#include "net/test/embedded_test_server/http_response.h"
#include "net/test/gtest_util.h"
#include "net/test/spawned_test_server/spawned_test_server.h"
#include "net/test/test_data_directory.h"
#include "net/test/test_with_task_environment.h"
#include "net/test/url_request/url_request_failed_job.h"
#include "net/test/url_request/url_request_mock_http_job.h"
#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
#include "net/url_request/redirect_util.h"
#include "net/url_request/referrer_policy.h"
#include "net/url_request/static_http_user_agent_settings.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_builder.h"
#include "net/url_request/url_request_filter.h"
#include "net/url_request/url_request_http_job.h"
#include "net/url_request/url_request_interceptor.h"
#include "net/url_request/url_request_redirect_job.h"
#include "net/url_request/url_request_test_job.h"
#include "net/url_request/url_request_test_util.h"
#include "net/url_request/websocket_handshake_userdata_key.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "url/url_constants.h"
#include "url/url_util.h"

#if BUILDFLAG(IS_WIN)
#include <objbase.h>

#include <windows.h>

#include <shlobj.h>
#include <wrl/client.h>

#include "base/win/scoped_com_initializer.h"
#endif

#if BUILDFLAG(IS_APPLE)
#include "base/mac/mac_util.h"
#endif

#if BUILDFLAG(ENABLE_REPORTING)
#include "net/network_error_logging/network_error_logging_service.h"
#include "net/network_error_logging/network_error_logging_test_util.h"
#endif  // BUILDFLAG(ENABLE_REPORTING)

#if BUILDFLAG(ENABLE_WEBSOCKETS)
#include "net/websockets/websocket_test_util.h"
#endif  // BUILDFLAG(ENABLE_WEBSOCKETS)

IsError;
IsOk;
RegisterDefaultHandlers;
_;
AnyOf;
ElementsAre;
IsEmpty;
Optional;
UnorderedElementsAre;

ASCIIToUTF16;
Time;
string;

namespace net {

namespace {

namespace test_default {
#include "net/http/transport_security_state_static_unittest_default.h"
}

const std::u16string kSecret(u"secret");
const std::u16string kUser(u"user");

const base::FilePath::CharType kTestFilePath[] = …);

// Tests load timing information in the case a fresh connection was used, with
// no proxy.
void TestLoadTimingNotReused(const LoadTimingInfo& load_timing_info,
                             int connect_timing_flags) { … }

// Same as above, but with proxy times.
void TestLoadTimingNotReusedWithProxy(const LoadTimingInfo& load_timing_info,
                                      int connect_timing_flags) { … }

// Same as above, but with a reused socket and proxy times.
void TestLoadTimingReusedWithProxy(const LoadTimingInfo& load_timing_info) { … }

CookieList GetAllCookies(URLRequestContext* request_context) { … }

void TestLoadTimingCacheHitNoNetwork(const LoadTimingInfo& load_timing_info) { … }

// Job that allows monitoring of its priority.
class PriorityMonitoringURLRequestJob : public URLRequestTestJob { … };

// Do a case-insensitive search through |haystack| for |needle|.
bool ContainsString(const std::string& haystack, const char* needle) { … }

std::unique_ptr<UploadDataStream> CreateSimpleUploadData(
    base::span<const uint8_t> data) { … }

// Verify that the SSLInfo of a successful SSL connection has valid values.
void CheckSSLInfo(const SSLInfo& ssl_info) { … }

// A network delegate that allows the user to choose a subset of request stages
// to block in. When blocking, the delegate can do one of the following:
//  * synchronously return a pre-specified error code, or
//  * asynchronously return that value via an automatically called callback,
//    or
//  * block and wait for the user to do a callback.
// Additionally, the user may also specify a redirect URL -- then each request
// with the current URL different from the redirect target will be redirected
// to that target, in the on-before-URL-request stage, independent of whether
// the delegate blocks in ON_BEFORE_URL_REQUEST or not.
class BlockingNetworkDelegate : public TestNetworkDelegate { … };

BlockingNetworkDelegate::BlockingNetworkDelegate(BlockMode block_mode)
    : … { … }

void BlockingNetworkDelegate::RunUntilBlocked() { … }

void BlockingNetworkDelegate::DoCallback(int response) { … }

void BlockingNetworkDelegate::OnBlocked() { … }

void BlockingNetworkDelegate::RunCallback(int response,
                                          CompletionOnceCallback callback) { … }

int BlockingNetworkDelegate::OnBeforeURLRequest(URLRequest* request,
                                                CompletionOnceCallback callback,
                                                GURL* new_url) { … }

int BlockingNetworkDelegate::OnBeforeStartTransaction(
    URLRequest* request,
    const HttpRequestHeaders& headers,
    OnBeforeStartTransactionCallback callback) { … }

int BlockingNetworkDelegate::OnHeadersReceived(
    URLRequest* request,
    CompletionOnceCallback callback,
    const HttpResponseHeaders* original_response_headers,
    scoped_refptr<HttpResponseHeaders>* override_response_headers,
    const IPEndPoint& endpoint,
    std::optional<GURL>* preserve_fragment_on_redirect_url) { … }

void BlockingNetworkDelegate::Reset() { … }

int BlockingNetworkDelegate::MaybeBlockStage(
    BlockingNetworkDelegate::Stage stage,
    CompletionOnceCallback callback) { … }

// OCSPErrorTestDelegate caches the SSLInfo passed to OnSSLCertificateError.
// This is needed because after the certificate failure, the URLRequest will
// retry the connection, and return a partial SSLInfo with a cached cert status.
// The partial SSLInfo does not have the OCSP information filled out.
class OCSPErrorTestDelegate : public TestDelegate { … };

#if !BUILDFLAG(IS_IOS)
// Compute the root cert's SPKI hash on the fly, to avoid hardcoding it within
// tests.
bool GetTestRootCertSPKIHash(SHA256HashValue* root_hash) { … }
#endif

}  // namespace

// Inherit PlatformTest since we require the autorelease pool on Mac OS X.
class URLRequestTest : public PlatformTest, public WithTaskEnvironment { … };

TEST_F(URLRequestTest, AboutBlankTest) { … }

TEST_F(URLRequestTest, InvalidUrlTest) { … }

// Test that URLRequest rejects WS URLs by default.
TEST_F(URLRequestTest, WsUrlTest) { … }

// Test that URLRequest rejects WSS URLs by default.
TEST_F(URLRequestTest, WssUrlTest) { … }

TEST_F(URLRequestTest, InvalidReferrerTest) { … }

TEST_F(URLRequestTest, RecordsSameOriginReferrerHistogram) { … }

TEST_F(URLRequestTest, RecordsCrossOriginReferrerHistogram) { … }

TEST_F(URLRequestTest, RecordsReferrerHistogramAgainOnRedirect) { … }

TEST_F(URLRequestTest, RecordsReferrrerWithInformativePath) { … }

TEST_F(URLRequestTest, RecordsReferrerWithInformativeQuery) { … }

TEST_F(URLRequestTest, RecordsReferrerWithoutInformativePathOrQuery) { … }

// A URLRequestInterceptor that allows setting the LoadTimingInfo value of the
// URLRequestJobs it creates.
class URLRequestInterceptorWithLoadTimingInfo : public URLRequestInterceptor { … };

// These tests inject a MockURLRequestInterceptor
class URLRequestLoadTimingTest : public URLRequestTest { … };

// "Normal" LoadTimingInfo as returned by a job.  Everything is in order, not
// reused.  |connect_time_flags| is used to indicate if there should be dns
// or SSL times, and |used_proxy| is used for proxy times.
LoadTimingInfo NormalLoadTimingInfo(base::TimeTicks now,
                                    int connect_time_flags,
                                    bool used_proxy) { … }

// Same as above, but in the case of a reused socket.
LoadTimingInfo NormalLoadTimingInfoReused(base::TimeTicks now,
                                          bool used_proxy) { … }

LoadTimingInfo RunURLRequestInterceptorLoadTimingTest(
    const LoadTimingInfo& job_load_timing,
    const URLRequestContext& context,
    URLRequestInterceptorWithLoadTimingInfo* interceptor) { … }

// Basic test that the intercept + load timing tests work.
TEST_F(URLRequestLoadTimingTest, InterceptLoadTiming) { … }

// Another basic test, with proxy and SSL times, but no DNS times.
TEST_F(URLRequestLoadTimingTest, InterceptLoadTimingProxy) { … }

// Make sure that URLRequest correctly adjusts proxy times when they're before
// |request_start|, due to already having a connected socket.  This happens in
// the case of reusing a SPDY session.  The connected socket is not considered
// reused in this test (May be a preconnect).
//
// To mix things up from the test above, assumes DNS times but no SSL times.
TEST_F(URLRequestLoadTimingTest, InterceptLoadTimingEarlyProxyResolution) { … }

// Same as above, but in the reused case.
TEST_F(URLRequestLoadTimingTest,
       InterceptLoadTimingEarlyProxyResolutionReused) { … }

// Make sure that URLRequest correctly adjusts connect times when they're before
// |request_start|, due to reusing a connected socket.  The connected socket is
// not considered reused in this test (May be a preconnect).
//
// To mix things up, the request has SSL times, but no DNS times.
TEST_F(URLRequestLoadTimingTest, InterceptLoadTimingEarlyConnect) { … }

// Make sure that URLRequest correctly adjusts connect times when they're before
// |request_start|, due to reusing a connected socket in the case that there
// are also proxy times.  The connected socket is not considered reused in this
// test (May be a preconnect).
//
// In this test, there are no SSL or DNS times.
TEST_F(URLRequestLoadTimingTest, InterceptLoadTimingEarlyConnectWithProxy) { … }

TEST_F(URLRequestTest, NetworkDelegateProxyError) { … }

// Test that when host resolution fails with `ERR_DNS_NAME_HTTPS_ONLY` for
// "http://" requests, scheme is upgraded to "https://".
TEST_F(URLRequestTest, DnsNameHttpsOnlyErrorCausesSchemeUpgrade) { … }

// Test that DNS-based scheme upgrade supports deferred redirect.
TEST_F(URLRequestTest, DnsNameHttpsOnlyErrorCausesSchemeUpgradeDeferred) { … }

#if BUILDFLAG(ENABLE_WEBSOCKETS)
// Test that requests with "ws" scheme are upgraded to "wss" when DNS
// indicates that the name is HTTPS-only.
TEST_F(URLRequestTest, DnsHttpsRecordPresentCausesWsSchemeUpgrade) { … }

// Test that same-site requests with "wss" scheme retain the
// `kStorageAccessGrantEligible` override, even if the initiator origin uses the
// HTTPS version of the site.
TEST_F(URLRequestTest, WssRequestsAreEligibleForStorageAccess) { … }
#endif  // BUILDFLAG(ENABLE_WEBSOCKETS)

TEST_F(URLRequestTest, DnsHttpsRecordAbsentNoSchemeUpgrade) { … }

TEST_F(URLRequestTest, SkipSecureDnsDisabledByDefault) { … }

TEST_F(URLRequestTest, SkipSecureDnsEnabled) { … }

// Make sure that NetworkDelegate::NotifyCompleted is called if
// content is empty.
TEST_F(URLRequestTest, RequestCompletionForEmptyResponse) { … }

// Make sure that SetPriority actually sets the URLRequest's priority
// correctly, both before and after start.
TEST_F(URLRequestTest, SetPriorityBasic) { … }

// Make sure that URLRequest calls SetPriority on a job before calling
// Start on it.
TEST_F(URLRequestTest, SetJobPriorityBeforeJobStart) { … }

// Make sure that URLRequest passes on its priority updates to its
// job.
TEST_F(URLRequestTest, SetJobPriority) { … }

// Setting the IGNORE_LIMITS load flag should be okay if the priority
// is MAXIMUM_PRIORITY.
TEST_F(URLRequestTest, PriorityIgnoreLimits) { … }

// This test verifies that URLRequest::Delegate's OnConnected() callback is
// never called if the request fails before connecting to a remote endpoint.
TEST_F(URLRequestTest, NotifyDelegateConnectedSkippedOnEarlyFailure) { … }

// This test verifies that URLRequest::Delegate's OnConnected() method
// is called once for simple redirect-less requests.
TEST_F(URLRequestTest, OnConnected) { … }

// This test verifies that URLRequest::Delegate's OnConnected() method is
// called after each redirect.
TEST_F(URLRequestTest, OnConnectedRedirect) { … }

// This test verifies that when the URLRequest Delegate returns an error from
// OnConnected(), the entire request fails with that error.
TEST_F(URLRequestTest, OnConnectedError) { … }

TEST_F(URLRequestTest, OnConnectedAsync) { … }

TEST_F(URLRequestTest, OnConnectedAsyncError) { … }

TEST_F(URLRequestTest, DelayedCookieCallback) { … }

TEST_F(URLRequestTest, DelayedCookieCallbackAsync) { … }

TEST_F(URLRequestTest, DoNotSendCookies) { … }

TEST_F(URLRequestTest, DoNotSaveCookies) { … }

TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy) { … }

// TODO(crbug.com/41225288) This test is flaky on iOS.
#if BUILDFLAG(IS_IOS)
#define MAYBE_DoNotSaveCookies_ViaPolicy …
#else
#define MAYBE_DoNotSaveCookies_ViaPolicy …
#endif
TEST_F(URLRequestTest, MAYBE_DoNotSaveCookies_ViaPolicy) { … }

TEST_F(URLRequestTest, DoNotSaveEmptyCookies) { … }

TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy_Async) { … }

TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy_Async) { … }

// Tests for SameSite cookies. The test param indicates whether the same-site
// calculation considers redirect chains.
class URLRequestSameSiteCookiesTest
    : public URLRequestTest,
      public ::testing::WithParamInterface<bool> { … };

TEST_P(URLRequestSameSiteCookiesTest, SameSiteCookies) { … }

TEST_P(URLRequestSameSiteCookiesTest, SameSiteCookies_Redirect) { … }

TEST_P(URLRequestSameSiteCookiesTest, SettingSameSiteCookies) { … }

// Tests special chrome:// scheme that is supposed to always attach SameSite
// cookies if the requested site is secure.
TEST_P(URLRequestSameSiteCookiesTest, SameSiteCookiesSpecialScheme) { … }

TEST_P(URLRequestSameSiteCookiesTest, SettingSameSiteCookies_Redirect) { … }

INSTANTIATE_TEST_SUITE_P(…);

TEST_F(URLRequestTest, PartitionedCookiesRedirect) { … }

// Tests that __Secure- cookies can't be set on non-secure origins.
TEST_F(URLRequestTest, SecureCookiePrefixOnNonsecureOrigin) { … }

TEST_F(URLRequestTest, SecureCookiePrefixNonsecure) { … }

TEST_F(URLRequestTest, SecureCookiePrefixSecure) { … }

// Tests that secure cookies can't be set on non-secure origins if strict secure
// cookies are enabled.
TEST_F(URLRequestTest, StrictSecureCookiesOnNonsecureOrigin) { … }

// FixedDateNetworkDelegate swaps out the server's HTTP Date response header
// value for the `fixed_date_` member.
class FixedDateNetworkDelegate : public TestNetworkDelegate { … };

int FixedDateNetworkDelegate::OnHeadersReceived(
    URLRequest* request,
    CompletionOnceCallback callback,
    const HttpResponseHeaders* original_response_headers,
    scoped_refptr<HttpResponseHeaders>* override_response_headers,
    const IPEndPoint& endpoint,
    std::optional<GURL>* preserve_fragment_on_redirect_url) { … }

// Test that cookie expiration times are adjusted for server/client clock
// skew and that we handle incorrect timezone specifier "UTC" in HTTP Date
// headers by defaulting to GMT. (crbug.com/135131)
TEST_F(URLRequestTest, AcceptClockSkewCookieWithWrongDateTimezone) { … }

// Check that it is impossible to change the referrer in the extra headers of
// an URLRequest.
TEST_F(URLRequestTest, DoNotOverrideReferrer) { … }

class URLRequestTestHTTP : public URLRequestTest { … };

namespace {

std::unique_ptr<test_server::HttpResponse> HandleRedirectConnect(
    const test_server::HttpRequest& request) { … }

}  // namespace

// In this unit test, we're using the HTTPTestServer as a proxy server and
// issuing a CONNECT request with the magic host name "www.redirect.com".
// The EmbeddedTestServer will return a 302 response, which we should not
// follow.
TEST_F(URLRequestTestHTTP, ProxyTunnelRedirectTest) { … }

// This is the same as the previous test, but checks that the network delegate
// registers the error.
TEST_F(URLRequestTestHTTP, NetworkDelegateTunnelConnectionFailed) { … }

// Tests that we can block and asynchronously return OK in various stages.
TEST_F(URLRequestTestHTTP, NetworkDelegateBlockAsynchronously) { … }

// Tests that the network delegate can block and cancel a request.
TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequest) { … }

// Helper function for NetworkDelegateCancelRequestAsynchronously and
// NetworkDelegateCancelRequestSynchronously. Sets up a blocking network
// delegate operating in |block_mode| and a request for |url|. It blocks the
// request in |stage| and cancels it with ERR_BLOCKED_BY_CLIENT.
void NetworkDelegateCancelRequest(BlockingNetworkDelegate::BlockMode block_mode,
                                  BlockingNetworkDelegate::Stage stage,
                                  const GURL& url) { … }

// The following 3 tests check that the network delegate can cancel a request
// synchronously in various stages of the request.
TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously1) { … }

TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously2) { … }

TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously3) { … }

// The following 3 tests check that the network delegate can cancel a request
// asynchronously in various stages of the request.
TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously1) { … }

TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously2) { … }

TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously3) { … }

// Tests that the network delegate can block and redirect a request to a new
// URL.
TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequest) { … }

// Tests that the network delegate can block and redirect a request to a new
// URL by setting a redirect_url and returning in OnBeforeURLRequest directly.
TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestSynchronously) { … }

// Tests that redirects caused by the network delegate preserve POST data.
TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestPost) { … }

// Tests that the network delegate can block and redirect a request to a new
// URL during OnHeadersReceived.
TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestOnHeadersReceived) { … }

// Tests that the network delegate can synchronously complete OnAuthRequired
// by taking no action. This indicates that the NetworkDelegate does not want to
// handle the challenge, and is passing the buck along to the
// URLRequest::Delegate.
TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncNoAction) { … }

// Tests that NetworkDelegate header overrides from the 401 response do not
// affect the 200 response. This is a regression test for
// https://crbug.com/801237.
TEST_F(URLRequestTestHTTP, NetworkDelegateOverrideHeadersWithAuth) { … }

// Tests that we can handle when a network request was canceled while we were
// waiting for the network delegate.
// Part 1: Request is cancelled while waiting for OnBeforeURLRequest callback.
TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting1) { … }

// Tests that we can handle when a network request was canceled while we were
// waiting for the network delegate.
// Part 2: Request is cancelled while waiting for OnBeforeStartTransaction
// callback.
TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting2) { … }

// Tests that we can handle when a network request was canceled while we were
// waiting for the network delegate.
// Part 3: Request is cancelled while waiting for OnHeadersReceived callback.
TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting3) { … }

namespace {

std::unique_ptr<test_server::HttpResponse> HandleServerAuthConnect(
    const test_server::HttpRequest& request) { … }

}  // namespace

// In this unit test, we're using the EmbeddedTestServer as a proxy server and
// issuing a CONNECT request with the magic host name "www.server-auth.com".
// The EmbeddedTestServer will return a 401 response, which we should balk at.
TEST_F(URLRequestTestHTTP, UnexpectedServerAuthTest) { … }

TEST_F(URLRequestTestHTTP, GetTest_NoCache) { … }

TEST_F(URLRequestTestHTTP, GetTest) { … }

TEST_F(URLRequestTestHTTP, GetTestLoadTiming) { … }

namespace {

// Sends the correct Content-Length matching the compressed length.
const char kZippedContentLengthCompressed[] = …;
// Sends an incorrect Content-Length matching the uncompressed length.
const char kZippedContentLengthUncompressed[] = …;
// Sends an incorrect Content-Length shorter than the compressed length.
const char kZippedContentLengthShort[] = …;
// Sends an incorrect Content-Length between the compressed and uncompressed
// lengths.
const char kZippedContentLengthMedium[] = …;
// Sends an incorrect Content-Length larger than both compressed and
// uncompressed lengths.
const char kZippedContentLengthLong[] = …;

// Sends |compressed_content| which, when decoded with deflate, should have
// length |uncompressed_length|. The Content-Length header will be sent based on
// which of the constants above is sent in the query string.
std::unique_ptr<test_server::HttpResponse> HandleZippedRequest(
    const std::string& compressed_content,
    size_t uncompressed_length,
    const test_server::HttpRequest& request) { … }

}  // namespace

TEST_F(URLRequestTestHTTP, GetZippedTest) { … }

TEST_F(URLRequestTestHTTP, RedirectLoadTiming) { … }

TEST_F(URLRequestTestHTTP, MultipleRedirectTest) { … }

// This is a regression test for https://crbug.com/942073.
TEST_F(URLRequestTestHTTP, RedirectEscaping) { … }

// First and second pieces of information logged by delegates to URLRequests.
const char kFirstDelegateInfo[] = …;
const char16_t kFirstDelegateInfo16[] = …;
const char kSecondDelegateInfo[] = …;
const char16_t kSecondDelegateInfo16[] = …;

// Logs delegate information to a URLRequest.  The first string is logged
// synchronously on Start(), using DELEGATE_INFO_DEBUG_ONLY.  The second is
// logged asynchronously, using DELEGATE_INFO_DISPLAY_TO_USER.  Then
// another asynchronous call is used to clear the delegate information
// before calling a callback.  The object then deletes itself.
class AsyncDelegateLogger : public base::RefCounted<AsyncDelegateLogger> { … };

// NetworkDelegate that logs delegate information before a request is started,
// before headers are sent, when headers are read, and when auth information
// is requested.  Uses AsyncDelegateLogger.
class AsyncLoggingNetworkDelegate : public TestNetworkDelegate { … };

// URLRequest::Delegate that logs delegate information when the headers
// are received, when each read completes, and during redirects.  Uses
// AsyncDelegateLogger.  Can optionally cancel a request in any phase.
//
// Inherits from TestDelegate to reuse the TestDelegate code to handle
// advancing to the next step in most cases, as well as cancellation.
class AsyncLoggingUrlRequestDelegate : public TestDelegate { … };

// Tests handling of delegate info before a request starts.
TEST_F(URLRequestTestHTTP, DelegateInfoBeforeStart) { … }

// Tests handling of delegate info from a network delegate.
TEST_F(URLRequestTestHTTP, NetworkDelegateInfo) { … }

// Tests handling of delegate info from a network delegate in the case of an
// HTTP redirect.
TEST_F(URLRequestTestHTTP, NetworkDelegateInfoRedirect) { … }

// Tests handling of delegate info from a URLRequest::Delegate.
TEST_F(URLRequestTestHTTP, URLRequestDelegateInfo) { … }

// Tests handling of delegate info from a URLRequest::Delegate in the case of
// an HTTP redirect.
TEST_F(URLRequestTestHTTP, URLRequestDelegateInfoOnRedirect) { … }

// Tests handling of delegate info from a URLRequest::Delegate in the case of
// an HTTP redirect, with cancellation at various points.
TEST_F(URLRequestTestHTTP, URLRequestDelegateOnRedirectCancelled) { … }

namespace {

const char kExtraHeader[] = …;
const char kExtraValue[] = …;

class RedirectWithAdditionalHeadersDelegate : public TestDelegate { … };

}  // namespace

TEST_F(URLRequestTestHTTP, RedirectWithAdditionalHeadersTest) { … }

namespace {

const char kExtraHeaderToRemove[] = …;

class RedirectWithHeaderRemovalDelegate : public TestDelegate { … };

}  // namespace

TEST_F(URLRequestTestHTTP, RedirectWithHeaderRemovalTest) { … }

TEST_F(URLRequestTestHTTP, CancelAfterStart) { … }

TEST_F(URLRequestTestHTTP, CancelInResponseStarted) { … }

TEST_F(URLRequestTestHTTP, CancelOnDataReceived) { … }

TEST_F(URLRequestTestHTTP, CancelDuringEofRead) { … }

TEST_F(URLRequestTestHTTP, CancelByDestroyingAfterStart) { … }

TEST_F(URLRequestTestHTTP, CancelWhileReadingFromCache) { … }

TEST_F(URLRequestTestHTTP, PostTest) { … }

TEST_F(URLRequestTestHTTP, PutTest) { … }

TEST_F(URLRequestTestHTTP, PostEmptyTest) { … }

TEST_F(URLRequestTestHTTP, PostFileTest) { … }

TEST_F(URLRequestTestHTTP, PostUnreadableFileTest) { … }

namespace {

// Adds a standard set of data to an upload for chunked upload integration
// tests.
void AddDataToUpload(ChunkedUploadDataStream::Writer* writer) { … }

// Checks that the upload data added in AddChunksToUpload() was echoed back from
// the server.
void VerifyReceivedDataMatchesChunks(URLRequest* r, TestDelegate* d) { … }

}  // namespace

TEST_F(URLRequestTestHTTP, TestPostChunkedDataBeforeStart) { … }

TEST_F(URLRequestTestHTTP, TestPostChunkedDataJustAfterStart) { … }

TEST_F(URLRequestTestHTTP, TestPostChunkedDataAfterStart) { … }

TEST_F(URLRequestTestHTTP, ResponseHeadersTest) { … }

// TODO(svaldez): iOS tests are flaky with EmbeddedTestServer and transport
// security state. (see http://crbug.com/550977).
#if !BUILDFLAG(IS_IOS)
TEST_F(URLRequestTestHTTP, ProcessSTS) { … }

TEST_F(URLRequestTestHTTP, STSNotProcessedOnIP) { … }

TEST_F(URLRequestTestHTTP, PKPBypassRecorded) { … }

TEST_F(URLRequestTestHTTP, ProcessSTSOnce) { … }

#endif  // !BUILDFLAG(IS_IOS)

#if BUILDFLAG(ENABLE_REPORTING)

TEST_F(URLRequestTestHTTP, NetworkErrorLogging_DontReportIfNetworkNotAccessed) { … }

TEST_F(URLRequestTestHTTP, NetworkErrorLogging_BasicSuccess) { … }

TEST_F(URLRequestTestHTTP, NetworkErrorLogging_BasicError) { … }

TEST_F(URLRequestTestHTTP, NetworkErrorLogging_Redirect) { … }

TEST_F(URLRequestTestHTTP, NetworkErrorLogging_RedirectWithoutLocationHeader) { … }

TEST_F(URLRequestTestHTTP, NetworkErrorLogging_Auth) { … }

TEST_F(URLRequestTestHTTP, NetworkErrorLogging_304Response) { … }

TEST_F(URLRequestTestHTTP, NetworkErrorLogging_CancelInResponseStarted) { … }

TEST_F(URLRequestTestHTTP, NetworkErrorLogging_CancelOnDataReceived) { … }

TEST_F(URLRequestTestHTTP, NetworkErrorLogging_CancelRedirect) { … }

#endif  // BUILDFLAG(ENABLE_REPORTING)

TEST_F(URLRequestTestHTTP, ContentTypeNormalizationTest) { … }

TEST_F(URLRequestTestHTTP, FileRedirect) { … }

TEST_F(URLRequestTestHTTP, DataRedirect) { … }

TEST_F(URLRequestTestHTTP, RestrictUnsafeRedirect) { … }

// Test that redirects to invalid URLs are rejected. See
// https://crbug.com/462272.
TEST_F(URLRequestTestHTTP, RedirectToInvalidURL) { … }

// Make sure redirects are cached, despite not reading their bodies.
TEST_F(URLRequestTestHTTP, CacheRedirect) { … }

// Make sure a request isn't cached when a NetworkDelegate forces a redirect
// when the headers are read, since the body won't have been read.
TEST_F(URLRequestTestHTTP, NoCacheOnNetworkDelegateRedirect) { … }

// Check that |preserve_fragment_on_redirect_url| is respected.
TEST_F(URLRequestTestHTTP, PreserveFragmentOnRedirectUrl) { … }

// Check that |preserve_fragment_on_redirect_url| has no effect when it doesn't
// match the URL being redirected to.
TEST_F(URLRequestTestHTTP, PreserveFragmentOnRedirectUrlMismatch) { … }

// When a URLRequestRedirectJob is created, the redirection must be followed and
// the reference fragment of the target URL must not be modified.
TEST_F(URLRequestTestHTTP, RedirectJobWithReferenceFragment) { … }

TEST_F(URLRequestTestHTTP, UnsupportedReferrerScheme) { … }

TEST_F(URLRequestTestHTTP, NoUserPassInReferrer) { … }

TEST_F(URLRequestTestHTTP, NoFragmentInReferrer) { … }

TEST_F(URLRequestTestHTTP, EmptyReferrerAfterValidReferrer) { … }

TEST_F(URLRequestTestHTTP, CapRefererHeaderLength) { … }

TEST_F(URLRequestTestHTTP, CancelRedirect) { … }

TEST_F(URLRequestTestHTTP, DeferredRedirect) { … }

TEST_F(URLRequestTestHTTP, DeferredRedirect_ModifiedHeaders) { … }

TEST_F(URLRequestTestHTTP, DeferredRedirect_RemovedHeaders) { … }

TEST_F(URLRequestTestHTTP, CancelDeferredRedirect) { … }

TEST_F(URLRequestTestHTTP, VaryHeader) { … }

TEST_F(URLRequestTestHTTP, BasicAuth) { … }

// Check that Set-Cookie headers in 401 responses are respected.
// http://crbug.com/6450
TEST_F(URLRequestTestHTTP, BasicAuthWithCookies) { … }

// Same test as above, except this time the restart is initiated earlier
// (without user intervention since identity is embedded in the URL).
TEST_F(URLRequestTestHTTP, BasicAuthWithCredentialsWithCookies) { … }

TEST_F(URLRequestTestHTTP, BasicAuthWithCookiesCancelAuth) { … }

// Tests the IsolationInfo is updated approiately on redirect.
TEST_F(URLRequestTestHTTP, IsolationInfoUpdatedOnRedirect) { … }

// Tests that |key_auth_cache_by_network_anonymization_key| is respected.
TEST_F(URLRequestTestHTTP, AuthWithNetworkAnonymizationKey) { … }

TEST_F(URLRequestTest, ReportCookieActivity) { … }

// Test that the SameSite-by-default CookieInclusionStatus warnings do not get
// set if the cookie would have been rejected for other reasons.
// Regression test for https://crbug.com/1027318.
TEST_F(URLRequestTest, NoCookieInclusionStatusWarningIfWouldBeExcludedAnyway) { … }

TEST_F(URLRequestTestHTTP, AuthChallengeCancelCookieCollect) { … }

TEST_F(URLRequestTestHTTP, AuthChallengeWithFilteredCookies) { … }

// Tests that load timing works as expected with auth and the cache.
TEST_F(URLRequestTestHTTP, BasicAuthLoadTiming) { … }

// In this test, we do a POST which the server will 302 redirect.
// The subsequent transaction should use GET, and should not send the
// Content-Type header.
// http://code.google.com/p/chromium/issues/detail?id=843
TEST_F(URLRequestTestHTTP, Post302RedirectGet) { … }

// The following tests check that we handle mutating the request for HTTP
// redirects as expected.
// See https://crbug.com/56373, https://crbug.com/102130, and
// https://crbug.com/465517.

TEST_F(URLRequestTestHTTP, Redirect301Tests) { … }

TEST_F(URLRequestTestHTTP, Redirect302Tests) { … }

TEST_F(URLRequestTestHTTP, Redirect303Tests) { … }

TEST_F(URLRequestTestHTTP, Redirect307Tests) { … }

TEST_F(URLRequestTestHTTP, Redirect308Tests) { … }

// Make sure that 308 responses without bodies are not treated as redirects.
// Certain legacy apis that pre-date the response code expect this behavior
// (Like Google Drive).
TEST_F(URLRequestTestHTTP, NoRedirectOn308WithoutLocationHeader) { … }

TEST_F(URLRequestTestHTTP, Redirect302PreserveReferenceFragment) { … }

TEST_F(URLRequestTestHTTP, RedirectWithFilteredCookies) { … }

TEST_F(URLRequestTestHTTP, RedirectPreserveFirstPartyURL) { … }

TEST_F(URLRequestTestHTTP, RedirectUpdateFirstPartyURL) { … }

TEST_F(URLRequestTestHTTP, InterceptPost302RedirectGet) { … }

TEST_F(URLRequestTestHTTP, InterceptPost307RedirectPost) { … }

// Check that default A-L header is sent.
TEST_F(URLRequestTestHTTP, DefaultAcceptLanguage) { … }

// Check that an empty A-L header is not sent. http://crbug.com/77365.
TEST_F(URLRequestTestHTTP, EmptyAcceptLanguage) { … }

// Check that if request overrides the A-L header, the default is not appended.
// See http://crbug.com/20894
TEST_F(URLRequestTestHTTP, OverrideAcceptLanguage) { … }

// Check that default A-E header is sent.
TEST_F(URLRequestTestHTTP, DefaultAcceptEncoding) { … }

// Check that it's possible to override the default A-E header.
TEST_F(URLRequestTestHTTP, DefaultAcceptEncodingOverriden) { … }

// Check that if request overrides the A-E header, the default is not appended.
// See http://crbug.com/47381
TEST_F(URLRequestTestHTTP, OverrideAcceptEncoding) { … }

// Check that setting the A-C header sends the proper header.
TEST_F(URLRequestTestHTTP, SetAcceptCharset) { … }

// Check that default User-Agent header is sent.
TEST_F(URLRequestTestHTTP, DefaultUserAgent) { … }

// Check that if request overrides the User-Agent header,
// the default is not appended.
// TODO(crbug.com/41225288) This test is flaky on iOS.
#if BUILDFLAG(IS_IOS)
#define MAYBE_OverrideUserAgent …
#else
#define MAYBE_OverrideUserAgent …
#endif
TEST_F(URLRequestTestHTTP, MAYBE_OverrideUserAgent) { … }

// Check that a NULL HttpUserAgentSettings causes the corresponding empty
// User-Agent header to be sent but does not send the Accept-Language and
// Accept-Charset headers.
TEST_F(URLRequestTestHTTP, EmptyHttpUserAgentSettings) { … }

// Make sure that URLRequest passes on its priority updates to
// newly-created jobs after the first one.
TEST_F(URLRequestTestHTTP, SetSubsequentJobPriority) { … }

// Check that creating a network request while entering/exiting suspend mode
// fails as it should.  This is the only case where an HttpTransactionFactory
// does not return an HttpTransaction.
TEST_F(URLRequestTestHTTP, NetworkSuspendTest) { … }

namespace {

// HttpTransactionFactory that synchronously fails to create transactions.
class FailingHttpTransactionFactory : public HttpTransactionFactory { … };

}  // namespace

// Check that when a request that fails to create an HttpTransaction can be
// cancelled while the failure notification is pending, and doesn't send two
// failure notifications.
//
// This currently only happens when in suspend mode and there's no cache, but
// just use a special HttpTransactionFactory, to avoid depending on those
// behaviors.
TEST_F(URLRequestTestHTTP, NetworkCancelAfterCreateTransactionFailsTest) { … }

TEST_F(URLRequestTestHTTP, NetworkAccessedSetOnNetworkRequest) { … }

TEST_F(URLRequestTestHTTP, NetworkAccessedClearOnCachedResponse) { … }

TEST_F(URLRequestTestHTTP, NetworkAccessedClearOnLoadOnlyFromCache) { … }

// Test that a single job with a THROTTLED priority completes
// correctly in the absence of contention.
TEST_F(URLRequestTestHTTP, ThrottledPriority) { … }

TEST_F(URLRequestTestHTTP, RawBodyBytesNoContentEncoding) { … }

TEST_F(URLRequestTestHTTP, RawBodyBytesGzipEncoding) { … }

// Check that if NetworkDelegate::OnBeforeStartTransaction returns an error,
// the delegate isn't called back synchronously.
TEST_F(URLRequestTestHTTP, TesBeforeStartTransactionFails) { … }

class URLRequestTestReferrerPolicy : public URLRequestTest { … };

TEST_F(URLRequestTestReferrerPolicy, HTTPToSameOriginHTTP) { … }

TEST_F(URLRequestTestReferrerPolicy, HTTPToCrossOriginHTTP) { … }

TEST_F(URLRequestTestReferrerPolicy, HTTPSToSameOriginHTTPS) { … }

TEST_F(URLRequestTestReferrerPolicy, HTTPSToCrossOriginHTTPS) { … }

TEST_F(URLRequestTestReferrerPolicy, HTTPToHTTPS) { … }

TEST_F(URLRequestTestReferrerPolicy, HTTPSToHTTP) { … }

class HTTPSRequestTest : public TestWithTaskEnvironment { … };

TEST_F(HTTPSRequestTest, HTTPSGetTest) { … }

TEST_F(HTTPSRequestTest, HTTPSMismatchedTest) { … }

TEST_F(HTTPSRequestTest, HTTPSExpiredTest) { … }

// A TestDelegate used to test that an appropriate net error code is provided
// when an SSL certificate error occurs.
class SSLNetErrorTestDelegate : public TestDelegate { … };

// Tests that the URLRequest::Delegate receives an appropriate net error code
// when an SSL certificate error occurs.
TEST_F(HTTPSRequestTest, SSLNetErrorReportedToDelegate) { … }

// TODO(svaldez): iOS tests are flaky with EmbeddedTestServer and transport
// security state. (see http://crbug.com/550977).
#if !BUILDFLAG(IS_IOS)
// This tests that a load of a domain with preloaded HSTS and HPKP with a
// certificate error sets the |certificate_errors_are_fatal| flag correctly.
// This flag will cause the interstitial to be fatal.
TEST_F(HTTPSRequestTest, HTTPSPreloadedHSTSTest) { … }

// This tests that cached HTTPS page loads do not cause any updates to the
// TransportSecurityState.
TEST_F(HTTPSRequestTest, HTTPSErrorsNoClobberTSSTest) { … }

// Make sure HSTS preserves a POST request's method and body.
TEST_F(HTTPSRequestTest, HSTSPreservesPosts) { … }

// Make sure that the CORS headers are added to cross-origin HSTS redirects.
TEST_F(HTTPSRequestTest, HSTSCrossOriginAddHeaders) { … }

namespace {

class SSLClientAuthTestDelegate : public TestDelegate { … };

class TestSSLPrivateKey : public SSLPrivateKey { … };

}  // namespace

// TODO(davidben): Test the rest of the code. Specifically,
// - Filtering which certificates to select.
// - Getting a certificate request in an SSL renegotiation sending the
//   HTTP request.
TEST_F(HTTPSRequestTest, ClientAuthNoCertificate) { … }

TEST_F(HTTPSRequestTest, ClientAuth) { … }

// Test that private keys that fail to sign anything get evicted from the cache.
TEST_F(HTTPSRequestTest, ClientAuthFailSigning) { … }

// Test that cached private keys that fail to sign anything trigger a
// retry. This is so we handle unplugged smartcards
// gracefully. https://crbug.com/813022.
TEST_F(HTTPSRequestTest, ClientAuthFailSigningRetry) { … }

TEST_F(HTTPSRequestTest, ResumeTest) { … }

// Test that sessions aren't resumed across URLRequestContexts.
TEST_F(HTTPSRequestTest, SSLSessionCacheShardTest) { … }

// Test that sessions started with privacy mode enabled cannot be resumed when
// it is disabled, and vice versa.
TEST_F(HTTPSRequestTest, NoSessionResumptionBetweenPrivacyModes) { … }

class HTTPSFallbackTest : public TestWithTaskEnvironment { … };

// Tests the TLS 1.0 fallback doesn't happen.
TEST_F(HTTPSFallbackTest, TLSv1NoFallback) { … }

// Tests the TLS 1.1 fallback doesn't happen.
TEST_F(HTTPSFallbackTest, TLSv1_1NoFallback) { … }

// Tests the TLS 1.2 fallback doesn't happen.
TEST_F(HTTPSFallbackTest, TLSv1_2NoFallback) { … }

class HTTPSSessionTest : public TestWithTaskEnvironment { … };

// Tests that session resumption is not attempted if an invalid certificate
// is presented.
TEST_F(HTTPSSessionTest, DontResumeSessionsForInvalidCertificates) { … }

// Interceptor to check that secure DNS has been disabled. Secure DNS should be
// disabled for any network fetch triggered during certificate verification as
// it could cause a deadlock.
class SecureDnsInterceptor : public net::URLRequestInterceptor { … };

class HTTPSCertNetFetchingTest : public HTTPSRequestTest { … };

// The test EV policy OID used for generated certs.
static const char kEVTestCertPolicy[] = …;

class HTTPSEVTest : public HTTPSCertNetFetchingTest { … };

class HTTPSOCSPTest : public HTTPSCertNetFetchingTest { … };

static bool UsingBuiltinCertVerifier() { … }

// SystemSupportsHardFailRevocationChecking returns true iff the current
// operating system supports revocation checking and can distinguish between
// situations where a given certificate lacks any revocation information (eg:
// no CRLDistributionPoints and no OCSP Responder AuthorityInfoAccess) and when
// revocation information cannot be obtained (eg: the CRL was unreachable).
// If it does not, then tests which rely on 'hard fail' behaviour should be
// skipped.
static bool SystemSupportsHardFailRevocationChecking() { … }

// SystemUsesChromiumEVMetadata returns true iff the current operating system
// uses Chromium's EV metadata (i.e. EVRootCAMetadata). If it does not, then
// several tests are effected because our testing EV certificate won't be
// recognised as EV.
static bool SystemUsesChromiumEVMetadata() { … }

static bool SystemSupportsOCSP() { … }

static bool SystemSupportsOCSPStapling() { … }

static bool SystemSupportsCRLSets() { … }

TEST_F(HTTPSEVTest, EVCheckNoOCSP) { … }

TEST_F(HTTPSOCSPTest, Valid) { … }

TEST_F(HTTPSOCSPTest, Revoked) { … }

TEST_F(HTTPSOCSPTest, Invalid) { … }

TEST_F(HTTPSOCSPTest, IntermediateValid) { … }

TEST_F(HTTPSOCSPTest, IntermediateResponseOldButStillValid) { … }

TEST_F(HTTPSOCSPTest, IntermediateResponseTooOldKnownRoot) { … }

TEST_F(HTTPSOCSPTest, IntermediateResponseTooOld) { … }

TEST_F(HTTPSOCSPTest, IntermediateRevoked) { … }

TEST_F(HTTPSOCSPTest, ValidStapled) { … }

TEST_F(HTTPSOCSPTest, RevokedStapled) { … }

TEST_F(HTTPSOCSPTest, OldStapledAndInvalidAIA) { … }

TEST_F(HTTPSOCSPTest, OldStapledButValidAIA) { … }

static const struct OCSPVerifyTestData { … } kOCSPVerifyData[] = …;

class HTTPSOCSPVerifyTest
    : public HTTPSOCSPTest,
      public testing::WithParamInterface<OCSPVerifyTestData> { … };

TEST_P(HTTPSOCSPVerifyTest, VerifyResult) { … }

INSTANTIATE_TEST_SUITE_P(…);

class HTTPSAIATest : public HTTPSCertNetFetchingTest { … };

TEST_F(HTTPSAIATest, AIAFetching) { … }

class HTTPSHardFailTest : public HTTPSOCSPTest { … };

TEST_F(HTTPSHardFailTest, Valid) { … }

TEST_F(HTTPSHardFailTest, Revoked) { … }

TEST_F(HTTPSHardFailTest, FailsOnOCSPInvalid) { … }

TEST_F(HTTPSHardFailTest, IntermediateResponseOldButStillValid) { … }

TEST_F(HTTPSHardFailTest, IntermediateResponseTooOld) { … }

TEST_F(HTTPSHardFailTest, ValidStapled) { … }

TEST_F(HTTPSHardFailTest, RevokedStapled) { … }

TEST_F(HTTPSHardFailTest, OldStapledAndInvalidAIA) { … }

TEST_F(HTTPSHardFailTest, OldStapledButValidAIA) { … }

class HTTPSCRLSetTest : public HTTPSCertNetFetchingTest { … };

TEST_F(HTTPSCRLSetTest, ExpiredCRLSet) { … }

TEST_F(HTTPSCRLSetTest, ExpiredCRLSetAndRevoked) { … }

TEST_F(HTTPSCRLSetTest, CRLSetRevoked) { … }

TEST_F(HTTPSCRLSetTest, CRLSetRevokedBySubject) { … }

HTTPSLocalCRLSetTest;

// Use a real CertVerifier to attempt to connect to the TestServer, and ensure
// that when a CRLSet is provided that marks a given SPKI (the TestServer's
// root SPKI) as known for interception, that it's adequately flagged.
TEST_F(HTTPSLocalCRLSetTest, KnownInterceptionBlocked) { … }

TEST_F(HTTPSLocalCRLSetTest, InterceptionBlockedAllowOverrideOnHSTS) { … }
#endif  // !BUILDFLAG(IS_IOS)

TEST_F(URLRequestTest, NetworkAccessedSetOnHostResolutionFailure) { … }

// Test that URLRequest is canceled correctly.
// See http://crbug.com/508900
TEST_F(URLRequestTest, URLRequestRedirectJobCancelRequest) { … }

#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS)
#define MAYBE_HeadersCallbacks …
#else
#define MAYBE_HeadersCallbacks …
#endif
TEST_F(URLRequestTestHTTP, MAYBE_HeadersCallbacks) { … }

TEST_F(URLRequestTestHTTP, HeadersCallbacksWithRedirect) { … }

TEST_F(URLRequestTest, HeadersCallbacksConnectFailed) { … }

TEST_F(URLRequestTestHTTP, HeadersCallbacksAuthRetry) { … }

TEST_F(URLRequestTest, UpgradeIfInsecureFlagSet) { … }

TEST_F(URLRequestTest, UpgradeIfInsecureFlagSetExplicitPort80) { … }

TEST_F(URLRequestTest, UpgradeIfInsecureFlagSetNonStandardPort) { … }

TEST_F(URLRequestTest, UpgradeIfInsecureFlagNotSet) { … }

// Test that URLRequests get properly tagged.
#if BUILDFLAG(IS_ANDROID)
TEST_F(URLRequestTestHTTP, TestTagging) {
  if (!CanGetTaggedBytes()) {
    DVLOG(0) << "Skipping test - GetTaggedBytes unsupported.";
    return;
  }

  ASSERT_TRUE(http_test_server()->Start());

  // The tag under which the system reports untagged traffic.
  static const int32_t UNTAGGED_TAG = 0;

  uint64_t old_traffic = GetTaggedBytes(UNTAGGED_TAG);

  // Untagged traffic should be tagged with tag UNTAGGED_TAG.
  TestDelegate delegate;
  std::unique_ptr<URLRequest> req(default_context().CreateRequest(
      http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &delegate,
      TRAFFIC_ANNOTATION_FOR_TESTS));
  EXPECT_EQ(SocketTag(), req->socket_tag());
  req->Start();
  delegate.RunUntilComplete();

  EXPECT_GT(GetTaggedBytes(UNTAGGED_TAG), old_traffic);

  int32_t tag_val1 = 0x12345678;
  SocketTag tag1(SocketTag::UNSET_UID, tag_val1);
  old_traffic = GetTaggedBytes(tag_val1);

  // Test specific tag value.
  req = default_context().CreateRequest(http_test_server()->GetURL("/"),
                                        DEFAULT_PRIORITY, &delegate,
                                        TRAFFIC_ANNOTATION_FOR_TESTS);
  req->set_socket_tag(tag1);
  EXPECT_EQ(tag1, req->socket_tag());
  req->Start();
  delegate.RunUntilComplete();

  EXPECT_GT(GetTaggedBytes(tag_val1), old_traffic);
}
#endif

namespace {

class ReadBufferingListener
    : public test_server::EmbeddedTestServerConnectionListener { … };

// Provides a response to the 0RTT request indicating whether it was received
// as early data, sending HTTP_TOO_EARLY if enabled.
class ZeroRTTResponse : public test_server::BasicHttpResponse { … };

std::unique_ptr<test_server::HttpResponse> HandleZeroRTTRequest(
    const test_server::HttpRequest& request) { … }

}  // namespace

class HTTPSEarlyDataTest : public TestWithTaskEnvironment { … };

// TLSEarlyDataTest tests that we handle early data correctly.
TEST_F(HTTPSEarlyDataTest, TLSEarlyDataTest) { … }

// TLSEarlyDataTest tests that we handle early data correctly for POST.
TEST_F(HTTPSEarlyDataTest, TLSEarlyDataPOSTTest) { … }

// TLSEarlyDataTest tests that the 0-RTT is enabled for idempotent POST request.
TEST_F(HTTPSEarlyDataTest, TLSEarlyDataIdempotentPOSTTest) { … }

// TLSEarlyDataTest tests that the 0-RTT is disabled for non-idempotent request.
TEST_F(HTTPSEarlyDataTest, TLSEarlyDataNonIdempotentRequestTest) { … }

std::unique_ptr<test_server::HttpResponse> HandleTooEarly(
    bool* sent_425,
    const test_server::HttpRequest& request) { … }

// Test that we handle 425 (Too Early) correctly.
TEST_F(HTTPSEarlyDataTest, TLSEarlyDataTooEarlyTest) { … }

// TLSEarlyDataRejectTest tests that we gracefully handle an early data reject
// and retry without early data.
TEST_F(HTTPSEarlyDataTest, TLSEarlyDataRejectTest) { … }

// TLSEarlyDataTLS12RejectTest tests that we gracefully handle an early data
// reject from a TLS 1.2 server and retry without early data.
TEST_F(HTTPSEarlyDataTest, TLSEarlyDataTLS12RejectTest) { … }

// Tests that AuthChallengeInfo is available on the request.
TEST_F(URLRequestTestHTTP, AuthChallengeInfo) { … }

TEST_F(URLRequestTestHTTP, ConnectNoSupported) { … }

class URLRequestDnsAliasTest : public TestWithTaskEnvironment { … };

TEST_F(URLRequestDnsAliasTest, WithDnsAliases) { … }

TEST_F(URLRequestDnsAliasTest, NoAdditionalDnsAliases) { … }

TEST_F(URLRequestTest, SetURLChain) { … }

TEST_F(URLRequestTest, SetIsolationInfoFromNak) { … }

TEST_F(URLRequestTest, CookiePartitionKey) { … }

class URLRequestMaybeAsyncFirstPartySetsTest
    : public URLRequestTest,
      public testing::WithParamInterface<bool> { … };

TEST_P(URLRequestMaybeAsyncFirstPartySetsTest, SimpleRequest) { … }

TEST_P(URLRequestMaybeAsyncFirstPartySetsTest, SingleRedirect) { … }

INSTANTIATE_TEST_SUITE_P(…);

class PartitionConnectionsByNetworkAnonymizationKey : public URLRequestTest { … };

TEST_F(PartitionConnectionsByNetworkAnonymizationKey,
       DifferentTopFrameSitesNeverShareConnections) { … }

TEST_F(PartitionConnectionsByNetworkAnonymizationKey,
       FirstPartyIsSeparatedFromCrossSiteFrames) { … }

TEST_F(
    PartitionConnectionsByNetworkAnonymizationKey,
    DifferentCrossSiteFramesAreSeparatedOnlyWhenNetworkAnonymizationKeyIsTripleKeyed) { … }

TEST_F(PartitionConnectionsByNetworkAnonymizationKey,
       DifferentNoncesAreAlwaysSeparated) { … }

class PatternedExpectBypassCacheNetworkDelegate : public TestNetworkDelegate { … };

class StorageAccessHeaderURLRequestTest : public URLRequestTestHTTP { … };

// This test case makes a request to `kStorageAccessRetryPath`, which responds
// with the "Activate-Storage-Access: retry" header. The browser then retries
// the request (including unpartitioned cookies, if applicable). The second
// response still includes the header, but the browser ignores it the second
// time, since retrying would not make any difference.
TEST_F(StorageAccessHeaderURLRequestTest, StorageAccessHeaderRetry) { … }

TEST_F(StorageAccessHeaderURLRequestTest,
       StorageAccessHeaderRetry_RedirectPrioritizesRetryHeader) { … }

TEST_F(StorageAccessHeaderURLRequestTest,
       StorageAccessHeaderRetry_AuthChallengeIgnoresRetryHeader) { … }

TEST_F(StorageAccessHeaderURLRequestTest,
       StorageAccessHeaderRetry_AuthWithoutChallengeHonorsRetryHeader) { … }

TEST_F(StorageAccessHeaderURLRequestTest,
       StorageAccessHeaderRetry_SurvivesPostAuthRetries) { … }

}  // namespace net