quic_chromium_client_session.cc | Explore in Territory

// 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/quic/quic_chromium_client_session.h"

#include <memory>
#include <set>
#include <string_view>
#include <utility>

#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/metrics/sparse_histogram.h"
#include "base/no_destructor.h"
#include "base/observer_list.h"
#include "base/ranges/algorithm.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/single_thread_task_runner.h"
#include "base/time/tick_clock.h"
#include "base/trace_event/memory_usage_estimator.h"
#include "base/values.h"
#include "net/base/connection_endpoint_metadata.h"
#include "net/base/features.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
#include "net/base/network_activity_monitor.h"
#include "net/base/network_anonymization_key.h"
#include "net/base/privacy_mode.h"
#include "net/base/session_usage.h"
#include "net/base/url_util.h"
#include "net/cert/signed_certificate_timestamp_and_status.h"
#include "net/dns/public/secure_dns_policy.h"
#include "net/http/transport_security_state.h"
#include "net/log/net_log_event_type.h"
#include "net/log/net_log_source_type.h"
#include "net/log/net_log_values.h"
#include "net/quic/address_utils.h"
#include "net/quic/crypto/proof_verifier_chromium.h"
#include "net/quic/quic_chromium_connection_helper.h"
#include "net/quic/quic_chromium_packet_writer.h"
#include "net/quic/quic_crypto_client_stream_factory.h"
#include "net/quic/quic_server_info.h"
#include "net/quic/quic_session_pool.h"
#include "net/socket/datagram_client_socket.h"
#include "net/spdy/spdy_http_utils.h"
#include "net/spdy/spdy_log_util.h"
#include "net/spdy/spdy_session.h"
#include "net/ssl/ssl_connection_status_flags.h"
#include "net/ssl/ssl_info.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_stream_priority.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quiche/quic/platform/api/quic_flags.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "net/websockets/websocket_quic_spdy_stream.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "url/origin.h"
#include "url/scheme_host_port.h"

namespace net {

namespace features {

BASE_FEATURE(…);

}  // namespace features

namespace {

base::OnceClosure& MidMigrationCallbackForTesting() { … }

// IPv6 packets have an additional 20 bytes of overhead than IPv4 packets.
const size_t kAdditionalOverheadForIPv6 = …;

// Maximum number of Readers that are created for any session due to
// connection migration. A new Reader is created every time this endpoint's
// IP address changes.
const size_t kMaxReadersPerQuicSession = …;

// Time to wait (in seconds) when no networks are available and
// migrating sessions need to wait for a new network to connect.
const size_t kWaitTimeForNewNetworkSecs = …;

const size_t kMinRetryTimeForDefaultNetworkSecs = …;

// These values are persisted to logs. Entries should not be renumbered,
// and numeric values should never be reused.
enum class AcceptChEntries { … };

void LogAcceptChFrameReceivedHistogram(bool has_valid_entry,
                                       bool has_invalid_entry) { … }

void LogAcceptChForOriginHistogram(bool value) { … }

void RecordConnectionCloseErrorCodeImpl(const std::string& histogram,
                                        uint64_t error,
                                        bool is_google_host,
                                        bool handshake_confirmed,
                                        bool has_ech_config_list) { … }

void LogMigrateToSocketStatus(bool success) { … }

void RecordConnectionCloseErrorCode(const quic::QuicConnectionCloseFrame& frame,
                                    quic::ConnectionCloseSource source,
                                    std::string_view hostname,
                                    bool handshake_confirmed,
                                    bool has_ech_config_list) { … }

base::Value::Dict NetLogQuicMigrationFailureParams(
    quic::QuicConnectionId connection_id,
    std::string_view reason) { … }

base::Value::Dict NetLogQuicMigrationSuccessParams(
    quic::QuicConnectionId connection_id) { … }

base::Value::Dict NetLogProbingResultParams(
    handles::NetworkHandle network,
    const quic::QuicSocketAddress* peer_address,
    bool is_success) { … }

base::Value::Dict NetLogAcceptChFrameReceivedParams(
    spdy::AcceptChOriginValuePair entry) { … }

base::Value::Dict NetLogReceivedOrigins(
    const std::set<url::SchemeHostPort>& received_origins) { … }

// Histogram for recording the different reasons that a QUIC session is unable
// to complete the handshake.
enum HandshakeFailureReason { … };

void RecordHandshakeFailureReason(HandshakeFailureReason reason) { … }

// Note: these values must be kept in sync with the corresponding values in:
// tools/metrics/histograms/histograms.xml
enum HandshakeState { … };

enum class ZeroRttState { … };

void RecordHandshakeState(HandshakeState state) { … }

std::string MigrationCauseToString(MigrationCause cause) { … }

base::Value::Dict NetLogQuicClientSessionParams(
    const NetLogWithSource& net_log,
    const QuicSessionKey* session_key,
    const quic::QuicConnectionId& connection_id,
    const quic::QuicConnectionId& client_connection_id,
    const quic::ParsedQuicVersionVector& supported_versions,
    int cert_verify_flags,
    bool require_confirmation,
    base::span<const uint8_t> ech_config_list) { … }

// TODO(fayang): Remove this when necessary data is collected.
void LogProbeResultToHistogram(MigrationCause cause, bool success) { … }

}  // namespace

// static
void QuicChromiumClientSession::SetMidMigrationCallbackForTesting(
    base::OnceClosure callback) { … }

QuicChromiumClientSession::Handle::Handle(
    const base::WeakPtr<QuicChromiumClientSession>& session,
    url::SchemeHostPort destination)
    : … { … }

QuicChromiumClientSession::Handle::~Handle() { … }

void QuicChromiumClientSession::Handle::OnCryptoHandshakeConfirmed() { … }

void QuicChromiumClientSession::Handle::OnSessionClosed(
    quic::ParsedQuicVersion quic_version,
    int net_error,
    quic::QuicErrorCode quic_error,
    quic::ConnectionCloseSource source,
    bool port_migration_detected,
    bool quic_connection_migration_attempted,
    bool quic_connection_migration_successful,
    LoadTimingInfo::ConnectTiming connect_timing,
    bool was_ever_used) { … }

bool QuicChromiumClientSession::Handle::IsConnected() const { … }

bool QuicChromiumClientSession::Handle::OneRttKeysAvailable() const { … }

const LoadTimingInfo::ConnectTiming&
QuicChromiumClientSession::Handle::GetConnectTiming() { … }

void QuicChromiumClientSession::Handle::PopulateNetErrorDetails(
    NetErrorDetails* details) const { … }

quic::ParsedQuicVersion QuicChromiumClientSession::Handle::GetQuicVersion()
    const { … }

std::unique_ptr<quic::QuicConnection::ScopedPacketFlusher>
QuicChromiumClientSession::Handle::CreatePacketBundler() { … }

bool QuicChromiumClientSession::Handle::SharesSameSession(
    const Handle& other) const { … }

int QuicChromiumClientSession::Handle::RequestStream(
    bool requires_confirmation,
    CompletionOnceCallback callback,
    const NetworkTrafficAnnotationTag& traffic_annotation) { … }

std::unique_ptr<QuicChromiumClientStream::Handle>
QuicChromiumClientSession::Handle::ReleaseStream() { … }

int QuicChromiumClientSession::Handle::WaitForHandshakeConfirmation(
    CompletionOnceCallback callback) { … }

void QuicChromiumClientSession::Handle::CancelRequest(StreamRequest* request) { … }

int QuicChromiumClientSession::Handle::TryCreateStream(StreamRequest* request) { … }

int QuicChromiumClientSession::Handle::GetPeerAddress(
    IPEndPoint* address) const { … }

int QuicChromiumClientSession::Handle::GetSelfAddress(
    IPEndPoint* address) const { … }

bool QuicChromiumClientSession::Handle::WasEverUsed() const { … }

const std::set<std::string>&
QuicChromiumClientSession::Handle::GetDnsAliasesForSessionKey(
    const QuicSessionKey& key) const { … }

#if BUILDFLAG(ENABLE_WEBSOCKETS)
std::unique_ptr<WebSocketQuicStreamAdapter>
QuicChromiumClientSession::Handle::CreateWebSocketQuicStreamAdapter(
    WebSocketQuicStreamAdapter::Delegate* delegate,
    base::OnceCallback<void(std::unique_ptr<WebSocketQuicStreamAdapter>)>
        callback,
    const NetworkTrafficAnnotationTag& traffic_annotation) { … }
#endif  // BUILDFLAG(ENABLE_WEBSOCKETS)

QuicChromiumClientSession::StreamRequest::StreamRequest(
    QuicChromiumClientSession::Handle* session,
    bool requires_confirmation,
    const NetworkTrafficAnnotationTag& traffic_annotation)
    : … { … }

QuicChromiumClientSession::StreamRequest::~StreamRequest() { … }

int QuicChromiumClientSession::StreamRequest::StartRequest(
    CompletionOnceCallback callback) { … }

std::unique_ptr<QuicChromiumClientStream::Handle>
QuicChromiumClientSession::StreamRequest::ReleaseStream() { … }

void QuicChromiumClientSession::StreamRequest::OnRequestCompleteSuccess(
    std::unique_ptr<QuicChromiumClientStream::Handle> stream) { … }

void QuicChromiumClientSession::StreamRequest::OnRequestCompleteFailure(
    int rv) { … }

void QuicChromiumClientSession::StreamRequest::OnIOComplete(int rv) { … }

void QuicChromiumClientSession::StreamRequest::DoCallback(int rv) { … }

int QuicChromiumClientSession::StreamRequest::DoLoop(int rv) { … }

int QuicChromiumClientSession::StreamRequest::DoWaitForConfirmation() { … }

int QuicChromiumClientSession::StreamRequest::DoWaitForConfirmationComplete(
    int rv) { … }

int QuicChromiumClientSession::StreamRequest::DoRequestStream() { … }

int QuicChromiumClientSession::StreamRequest::DoRequestStreamComplete(int rv) { … }

QuicChromiumClientSession::QuicChromiumPathValidationContext::
    QuicChromiumPathValidationContext(
        const quic::QuicSocketAddress& self_address,
        const quic::QuicSocketAddress& peer_address,
        handles::NetworkHandle network,
        std::unique_ptr<QuicChromiumPacketWriter> writer,
        std::unique_ptr<QuicChromiumPacketReader> reader)
    : … { … }

QuicChromiumClientSession::QuicChromiumPathValidationContext::
    ~QuicChromiumPathValidationContext() = default;

handles::NetworkHandle
QuicChromiumClientSession::QuicChromiumPathValidationContext::network() { … }
quic::QuicPacketWriter*
QuicChromiumClientSession::QuicChromiumPathValidationContext::WriterToUse() { … }
std::unique_ptr<QuicChromiumPacketWriter>
QuicChromiumClientSession::QuicChromiumPathValidationContext::ReleaseWriter() { … }
std::unique_ptr<QuicChromiumPacketReader>
QuicChromiumClientSession::QuicChromiumPathValidationContext::ReleaseReader() { … }

QuicChromiumClientSession::ConnectionMigrationValidationResultDelegate::
    ConnectionMigrationValidationResultDelegate(
        QuicChromiumClientSession* session)
    : … { … }

void QuicChromiumClientSession::ConnectionMigrationValidationResultDelegate::
    OnPathValidationSuccess(
        std::unique_ptr<quic::QuicPathValidationContext> context,
        quic::QuicTime start_time) { … }

void QuicChromiumClientSession::ConnectionMigrationValidationResultDelegate::
    OnPathValidationFailure(
        std::unique_ptr<quic::QuicPathValidationContext> context) { … }

QuicChromiumClientSession::PortMigrationValidationResultDelegate::
    PortMigrationValidationResultDelegate(QuicChromiumClientSession* session)
    : … { … }

void QuicChromiumClientSession::PortMigrationValidationResultDelegate::
    OnPathValidationSuccess(
        std::unique_ptr<quic::QuicPathValidationContext> context,
        quic::QuicTime start_time) { … }

void QuicChromiumClientSession::PortMigrationValidationResultDelegate::
    OnPathValidationFailure(
        std::unique_ptr<quic::QuicPathValidationContext> context) { … }

QuicChromiumClientSession::ServerPreferredAddressValidationResultDelegate::
    ServerPreferredAddressValidationResultDelegate(
        QuicChromiumClientSession* session)
    : … { … }

void QuicChromiumClientSession::ServerPreferredAddressValidationResultDelegate::
    OnPathValidationSuccess(
        std::unique_ptr<quic::QuicPathValidationContext> context,
        quic::QuicTime start_time) { … }

void QuicChromiumClientSession::ServerPreferredAddressValidationResultDelegate::
    OnPathValidationFailure(
        std::unique_ptr<quic::QuicPathValidationContext> context) { … }

QuicChromiumClientSession::QuicChromiumPathValidationWriterDelegate::
    QuicChromiumPathValidationWriterDelegate(
        QuicChromiumClientSession* session,
        base::SequencedTaskRunner* task_runner)
    : … { … }

QuicChromiumClientSession::QuicChromiumPathValidationWriterDelegate::
    ~QuicChromiumPathValidationWriterDelegate() = default;

int QuicChromiumClientSession::QuicChromiumPathValidationWriterDelegate::
    HandleWriteError(
        int error_code,
        scoped_refptr<QuicChromiumPacketWriter::ReusableIOBuffer> last_packet) { … }

void QuicChromiumClientSession::QuicChromiumPathValidationWriterDelegate::
    OnWriteError(int error_code) { … }
void QuicChromiumClientSession::QuicChromiumPathValidationWriterDelegate::
    OnWriteUnblocked() { … }

void QuicChromiumClientSession::QuicChromiumPathValidationWriterDelegate::
    NotifySessionProbeFailed(handles::NetworkHandle network) { … }

void QuicChromiumClientSession::QuicChromiumPathValidationWriterDelegate::
    set_peer_address(const quic::QuicSocketAddress& peer_address) { … }

void QuicChromiumClientSession::QuicChromiumPathValidationWriterDelegate::
    set_network(handles::NetworkHandle network) { … }

QuicChromiumClientSession::QuicChromiumClientSession(
    quic::QuicConnection* connection,
    std::unique_ptr<DatagramClientSocket> socket,
    QuicSessionPool* session_pool,
    QuicCryptoClientStreamFactory* crypto_client_stream_factory,
    const quic::QuicClock* clock,
    TransportSecurityState* transport_security_state,
    SSLConfigService* ssl_config_service,
    std::unique_ptr<QuicServerInfo> server_info,
    const QuicSessionKey& session_key,
    bool require_confirmation,
    bool migrate_session_early_v2,
    bool migrate_sessions_on_network_change_v2,
    handles::NetworkHandle default_network,
    quic::QuicTime::Delta retransmittable_on_wire_timeout,
    bool migrate_idle_session,
    bool allow_port_migration,
    base::TimeDelta idle_migration_period,
    int multi_port_probing_interval,
    base::TimeDelta max_time_on_non_default_network,
    int max_migrations_to_non_default_network_on_write_error,
    int max_migrations_to_non_default_network_on_path_degrading,
    int yield_after_packets,
    quic::QuicTime::Delta yield_after_duration,
    int cert_verify_flags,
    const quic::QuicConfig& config,
    std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config,
    const char* const connection_description,
    base::TimeTicks dns_resolution_start_time,
    base::TimeTicks dns_resolution_end_time,
    const base::TickClock* tick_clock,
    base::SequencedTaskRunner* task_runner,
    std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
    const ConnectionEndpointMetadata& metadata,
    bool report_ecn,
    bool enable_origin_frame,
    const NetLogWithSource& net_log)
    : … { … }

QuicChromiumClientSession::~QuicChromiumClientSession() { … }

void QuicChromiumClientSession::Initialize() { … }

size_t QuicChromiumClientSession::WriteHeadersOnHeadersStream(
    quic::QuicStreamId id,
    quiche::HttpHeaderBlock headers,
    bool fin,
    const spdy::SpdyStreamPrecedence& precedence,
    quiche::QuicheReferenceCountedPointer<quic::QuicAckListenerInterface>
        ack_listener) { … }

void QuicChromiumClientSession::OnHttp3GoAway(uint64_t id) { … }

void QuicChromiumClientSession::OnAcceptChFrameReceivedViaAlps(
    const quic::AcceptChFrame& frame) { … }

void QuicChromiumClientSession::OnOriginFrame(const quic::OriginFrame& frame) { … }

void QuicChromiumClientSession::AddHandle(Handle* handle) { … }

void QuicChromiumClientSession::RemoveHandle(Handle* handle) { … }

void QuicChromiumClientSession::AddConnectivityObserver(
    ConnectivityObserver* observer) { … }

void QuicChromiumClientSession::RemoveConnectivityObserver(
    ConnectivityObserver* observer) { … }

// TODO(zhongyi): replace migration_session_* booleans with
// ConnectionMigrationMode.
ConnectionMigrationMode QuicChromiumClientSession::connection_migration_mode()
    const { … }

int QuicChromiumClientSession::WaitForHandshakeConfirmation(
    CompletionOnceCallback callback) { … }

int QuicChromiumClientSession::TryCreateStream(StreamRequest* request) { … }

void QuicChromiumClientSession::CancelRequest(StreamRequest* request) { … }

bool QuicChromiumClientSession::ShouldCreateOutgoingBidirectionalStream() { … }

bool QuicChromiumClientSession::ShouldCreateOutgoingUnidirectionalStream() { … }

bool QuicChromiumClientSession::WasConnectionEverUsed() { … }

QuicChromiumClientStream*
QuicChromiumClientSession::CreateOutgoingBidirectionalStream() { … }

QuicChromiumClientStream*
QuicChromiumClientSession::CreateOutgoingUnidirectionalStream() { … }

QuicChromiumClientStream*
QuicChromiumClientSession::CreateOutgoingReliableStreamImpl(
    const NetworkTrafficAnnotationTag& traffic_annotation) { … }

quic::QuicCryptoClientStream*
QuicChromiumClientSession::GetMutableCryptoStream() { … }

const quic::QuicCryptoClientStream* QuicChromiumClientSession::GetCryptoStream()
    const { … }

int QuicChromiumClientSession::GetRemoteEndpoint(IPEndPoint* endpoint) { … }

// TODO(rtenneti): Add unittests for GetSSLInfo which exercise the various ways
// we learn about SSL info (sync vs async vs cached).
bool QuicChromiumClientSession::GetSSLInfo(SSLInfo* ssl_info) const { … }

std::string_view QuicChromiumClientSession::GetAcceptChViaAlps(
    const url::SchemeHostPort& scheme_host_port) const { … }

int QuicChromiumClientSession::CryptoConnect(CompletionOnceCallback callback) { … }

int QuicChromiumClientSession::GetNumSentClientHellos() const { … }

bool QuicChromiumClientSession::CanPool(
    std::string_view hostname,
    const QuicSessionKey& other_session_key) const { … }

bool QuicChromiumClientSession::ShouldCreateIncomingStream(
    quic::QuicStreamId id) { … }

QuicChromiumClientStream* QuicChromiumClientSession::CreateIncomingStream(
    quic::QuicStreamId id) { … }

QuicChromiumClientStream* QuicChromiumClientSession::CreateIncomingStream(
    quic::PendingStream* pending) { … }

QuicChromiumClientStream*
QuicChromiumClientSession::CreateIncomingReliableStreamImpl(
    quic::QuicStreamId id,
    const NetworkTrafficAnnotationTag& traffic_annotation) { … }

QuicChromiumClientStream*
QuicChromiumClientSession::CreateIncomingReliableStreamImpl(
    quic::PendingStream* pending,
    const NetworkTrafficAnnotationTag& traffic_annotation) { … }

void QuicChromiumClientSession::OnStreamClosed(quic::QuicStreamId stream_id) { … }

void QuicChromiumClientSession::OnCanCreateNewOutgoingStream(
    bool unidirectional) { … }

quic::QuicSSLConfig QuicChromiumClientSession::GetSSLConfig() const { … }

void QuicChromiumClientSession::OnConfigNegotiated() { … }

void QuicChromiumClientSession::SetDefaultEncryptionLevel(
    quic::EncryptionLevel level) { … }

void QuicChromiumClientSession::OnTlsHandshakeComplete() { … }

void QuicChromiumClientSession::OnNewEncryptionKeyAvailable(
    quic::EncryptionLevel level,
    std::unique_ptr<quic::QuicEncrypter> encrypter) { … }

void QuicChromiumClientSession::LogZeroRttStats() { … }

void QuicChromiumClientSession::OnCryptoHandshakeMessageSent(
    const quic::CryptoHandshakeMessage& message) { … }

void QuicChromiumClientSession::OnCryptoHandshakeMessageReceived(
    const quic::CryptoHandshakeMessage& message) { … }

void QuicChromiumClientSession::OnGoAway(const quic::QuicGoAwayFrame& frame) { … }

void QuicChromiumClientSession::OnConnectionClosed(
    const quic::QuicConnectionCloseFrame& frame,
    quic::ConnectionCloseSource source) { … }

void QuicChromiumClientSession::OnSuccessfulVersionNegotiation(
    const quic::ParsedQuicVersion& version) { … }

int QuicChromiumClientSession::HandleWriteError(
    int error_code,
    scoped_refptr<QuicChromiumPacketWriter::ReusableIOBuffer> packet) { … }

void QuicChromiumClientSession::MigrateSessionOnWriteError(
    int error_code,
    quic::QuicPacketWriter* writer) { … }

void QuicChromiumClientSession::FinishMigrateSessionOnWriteError(
    handles::NetworkHandle new_network,
    MigrationResult result) { … }

void QuicChromiumClientSession::OnNoNewNetwork() { … }

void QuicChromiumClientSession::WriteToNewSocket() { … }

void QuicChromiumClientSession::OnMigrationTimeout(size_t num_sockets) { … }

void QuicChromiumClientSession::OnPortMigrationProbeSucceeded(
    handles::NetworkHandle network,
    const quic::QuicSocketAddress& peer_address,
    const quic::QuicSocketAddress& self_address,
    std::unique_ptr<QuicChromiumPacketWriter> writer,
    std::unique_ptr<QuicChromiumPacketReader> reader) { … }

void QuicChromiumClientSession::OnConnectionMigrationProbeSucceeded(
    handles::NetworkHandle network,
    const quic::QuicSocketAddress& peer_address,
    const quic::QuicSocketAddress& self_address,
    std::unique_ptr<QuicChromiumPacketWriter> writer,
    std::unique_ptr<QuicChromiumPacketReader> reader) { … }

void QuicChromiumClientSession::OnServerPreferredAddressProbeSucceeded(
    handles::NetworkHandle network,
    const quic::QuicSocketAddress& peer_address,
    const quic::QuicSocketAddress& self_address,
    std::unique_ptr<QuicChromiumPacketWriter> writer,
    std::unique_ptr<QuicChromiumPacketReader> reader) { … }

void QuicChromiumClientSession::OnProbeFailed(
    handles::NetworkHandle network,
    const quic::QuicSocketAddress& peer_address) { … }

void QuicChromiumClientSession::OnNetworkConnected(
    handles::NetworkHandle network) { … }

void QuicChromiumClientSession::OnNetworkDisconnectedV2(
    handles::NetworkHandle disconnected_network) { … }

void QuicChromiumClientSession::OnNetworkMadeDefault(
    handles::NetworkHandle new_network) { … }

void QuicChromiumClientSession::MigrateNetworkImmediately(
    handles::NetworkHandle network) { … }

void QuicChromiumClientSession::FinishMigrateNetworkImmediately(
    handles::NetworkHandle network,
    MigrationResult result) { … }

void QuicChromiumClientSession::OnWriteError(int error_code) { … }

void QuicChromiumClientSession::OnWriteUnblocked() { … }

void QuicChromiumClientSession::OnPathDegrading() { … }

void QuicChromiumClientSession::OnForwardProgressMadeAfterPathDegrading() { … }

void QuicChromiumClientSession::OnKeyUpdate(quic::KeyUpdateReason reason) { … }

void QuicChromiumClientSession::OnProofValid(
    const quic::QuicCryptoClientConfig::CachedState& cached) { … }

void QuicChromiumClientSession::OnProofVerifyDetailsAvailable(
    const quic::ProofVerifyDetails& verify_details) { … }

void QuicChromiumClientSession::StartReading() { … }

void QuicChromiumClientSession::CloseSessionOnError(
    int net_error,
    quic::QuicErrorCode quic_error,
    quic::ConnectionCloseBehavior behavior) { … }

void QuicChromiumClientSession::CloseSessionOnErrorLater(
    int net_error,
    quic::QuicErrorCode quic_error,
    quic::ConnectionCloseBehavior behavior) { … }

void QuicChromiumClientSession::NotifyAllStreamsOfError(int net_error) { … }

void QuicChromiumClientSession::CloseAllHandles(int net_error) { … }

void QuicChromiumClientSession::CancelAllRequests(int net_error) { … }

void QuicChromiumClientSession::NotifyRequestsOfConfirmation(int net_error) { … }

void QuicChromiumClientSession::MaybeMigrateToDifferentPortOnPathDegrading() { … }

void QuicChromiumClientSession::
    MaybeMigrateToAlternateNetworkOnPathDegrading() { … }

void QuicChromiumClientSession::MaybeStartProbing(
    ProbingCallback probing_callback,
    handles::NetworkHandle network,
    const quic::QuicSocketAddress& peer_address) { … }

void QuicChromiumClientSession::CreateContextForMultiPortPath(
    std::unique_ptr<quic::MultiPortPathContextObserver> context_observer) { … }

void QuicChromiumClientSession::FinishCreateContextForMultiPortPath(
    std::unique_ptr<quic::MultiPortPathContextObserver> context_observer,
    std::unique_ptr<DatagramClientSocket> probing_socket,
    int rv) { … }

void QuicChromiumClientSession::MigrateToMultiPortPath(
    std::unique_ptr<quic::QuicPathValidationContext> context) { … }

void QuicChromiumClientSession::StartProbing(
    ProbingCallback probing_callback,
    handles::NetworkHandle network,
    const quic::QuicSocketAddress& peer_address) { … }

void QuicChromiumClientSession::FinishStartProbing(
    ProbingCallback probing_callback,
    std::unique_ptr<DatagramClientSocket> probing_socket,
    handles::NetworkHandle network,
    const quic::QuicSocketAddress& peer_address,
    int rv) { … }

void QuicChromiumClientSession::StartMigrateBackToDefaultNetworkTimer(
    base::TimeDelta delay) { … }

void QuicChromiumClientSession::CancelMigrateBackToDefaultNetworkTimer() { … }

void QuicChromiumClientSession::TryMigrateBackToDefaultNetwork(
    base::TimeDelta timeout) { … }

void QuicChromiumClientSession::FinishTryMigrateBackToDefaultNetwork(
    base::TimeDelta timeout,
    ProbingResult result) { … }

void QuicChromiumClientSession::MaybeRetryMigrateBackToDefaultNetwork() { … }

bool QuicChromiumClientSession::CheckIdleTimeExceedsIdleMigrationPeriod() { … }

void QuicChromiumClientSession::ResetNonMigratableStreams() { … }

void QuicChromiumClientSession::LogMetricsOnNetworkDisconnected() { … }

void QuicChromiumClientSession::LogMetricsOnNetworkMadeDefault() { … }

void QuicChromiumClientSession::LogMigrationResultToHistogram(
    QuicConnectionMigrationStatus status) { … }

void QuicChromiumClientSession::LogHandshakeStatusOnMigrationSignal() const { … }

void QuicChromiumClientSession::HistogramAndLogMigrationFailure(
    QuicConnectionMigrationStatus status,
    quic::QuicConnectionId connection_id,
    const char* reason) { … }

void QuicChromiumClientSession::HistogramAndLogMigrationSuccess(
    quic::QuicConnectionId connection_id) { … }

base::Value::Dict QuicChromiumClientSession::GetInfoAsValue(
    const std::set<HostPortPair>& aliases) { … }

bool QuicChromiumClientSession::gquic_zero_rtt_disabled() const { … }

std::unique_ptr<QuicChromiumClientSession::Handle>
QuicChromiumClientSession::CreateHandle(url::SchemeHostPort destination) { … }

bool QuicChromiumClientSession::OnReadError(
    int result,
    const DatagramClientSocket* socket) { … }

bool QuicChromiumClientSession::OnPacket(
    const quic::QuicReceivedPacket& packet,
    const quic::QuicSocketAddress& local_address,
    const quic::QuicSocketAddress& peer_address) { … }

void QuicChromiumClientSession::NotifyFactoryOfSessionGoingAway() { … }

void QuicChromiumClientSession::NotifyFactoryOfSessionClosedLater() { … }

void QuicChromiumClientSession::NotifyFactoryOfSessionClosed() { … }

void QuicChromiumClientSession::OnCryptoHandshakeComplete() { … }

void QuicChromiumClientSession::Migrate(handles::NetworkHandle network,
                                        IPEndPoint peer_address,
                                        bool close_session_on_error,
                                        MigrationCallback migration_callback) { … }

void QuicChromiumClientSession::FinishMigrate(
    std::unique_ptr<DatagramClientSocket> socket,
    IPEndPoint peer_address,
    bool close_session_on_error,
    MigrationCallback callback,
    int rv) { … }

void QuicChromiumClientSession::DoMigrationCallback(MigrationCallback callback,
                                                    MigrationResult rv) { … }

bool QuicChromiumClientSession::MigrateToSocket(
    const quic::QuicSocketAddress& self_address,
    const quic::QuicSocketAddress& peer_address,
    std::unique_ptr<QuicChromiumPacketReader> reader,
    std::unique_ptr<QuicChromiumPacketWriter> writer) { … }

void QuicChromiumClientSession::PopulateNetErrorDetails(
    NetErrorDetails* details) const { … }

const DatagramClientSocket* QuicChromiumClientSession::GetDefaultSocket()
    const { … }

handles::NetworkHandle QuicChromiumClientSession::GetCurrentNetwork() const { … }

void QuicChromiumClientSession::OnServerPreferredAddressAvailable(
    const quic::QuicSocketAddress& server_preferred_address) { … }

const LoadTimingInfo::ConnectTiming&
QuicChromiumClientSession::GetConnectTiming() { … }

quic::ParsedQuicVersion QuicChromiumClientSession::GetQuicVersion() const { … }

const std::set<std::string>&
QuicChromiumClientSession::GetDnsAliasesForSessionKey(
    const QuicSessionKey& key) const { … }

quic::QuicPacketLength
QuicChromiumClientSession::Handle::GetGuaranteedLargestMessagePayload() const { … }

#if BUILDFLAG(ENABLE_WEBSOCKETS)
std::unique_ptr<WebSocketQuicStreamAdapter>
QuicChromiumClientSession::CreateWebSocketQuicStreamAdapterImpl(
    WebSocketQuicStreamAdapter::Delegate* delegate) { … }

std::unique_ptr<WebSocketQuicStreamAdapter>
QuicChromiumClientSession::CreateWebSocketQuicStreamAdapter(
    WebSocketQuicStreamAdapter::Delegate* delegate,
    base::OnceCallback<void(std::unique_ptr<WebSocketQuicStreamAdapter>)>
        callback,
    StreamRequest* stream_request) { … }
#endif  // BUILDFLAG(ENABLE_WEBSOCKETS)

}  // namespace net
chromium/net/quic/quic_chromium_client_session.cc
