chromium/net/third_party/quiche/src/quiche/quic/tools/quic_spdy_client_base.cc

// Copyright (c) 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "quiche/quic/tools/quic_spdy_client_base.h"

#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>


#include "absl/strings/numbers.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "quiche/quic/core/crypto/quic_random.h"
#include "quiche/quic/core/http/spdy_utils.h"
#include "quiche/quic/core/quic_server_id.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_logging.h"
#include "quiche/common/quiche_text_utils.h"

HttpHeaderBlock;

namespace quic {

QuicSpdyClientBase::QuicSpdyClientBase(
    const QuicServerId& server_id,
    const ParsedQuicVersionVector& supported_versions, const QuicConfig& config,
    QuicConnectionHelperInterface* helper, QuicAlarmFactory* alarm_factory,
    std::unique_ptr<NetworkHelper> network_helper,
    std::unique_ptr<ProofVerifier> proof_verifier,
    std::unique_ptr<SessionCache> session_cache)
    : … { … }

QuicSpdyClientBase::~QuicSpdyClientBase() { … }

QuicSpdyClientSession* QuicSpdyClientBase::client_session() { … }

const QuicSpdyClientSession* QuicSpdyClientBase::client_session() const { … }

void QuicSpdyClientBase::InitializeSession() { … }

void QuicSpdyClientBase::OnClose(QuicSpdyStream* stream) { … }

std::unique_ptr<QuicSession> QuicSpdyClientBase::CreateQuicClientSession(
    const quic::ParsedQuicVersionVector& supported_versions,
    QuicConnection* connection) { … }

void QuicSpdyClientBase::SendRequest(const HttpHeaderBlock& headers,
                                     absl::string_view body, bool fin) { … }

void QuicSpdyClientBase::SendRequestInternal(HttpHeaderBlock sanitized_headers,
                                             absl::string_view body, bool fin) { … }

void QuicSpdyClientBase::SendRequestAndWaitForResponse(
    const HttpHeaderBlock& headers, absl::string_view body, bool fin) { … }

void QuicSpdyClientBase::SendRequestsAndWaitForResponse(
    const std::vector<std::string>& url_list) { … }

QuicSpdyClientStream* QuicSpdyClientBase::CreateClientStream() { … }

bool QuicSpdyClientBase::goaway_received() const { … }

std::optional<uint64_t> QuicSpdyClientBase::last_received_http3_goaway_id() { … }

bool QuicSpdyClientBase::EarlyDataAccepted() { … }

bool QuicSpdyClientBase::ReceivedInchoateReject() { … }

int QuicSpdyClientBase::GetNumSentClientHellosFromSession() { … }

int QuicSpdyClientBase::GetNumReceivedServerConfigUpdatesFromSession() { … }

int QuicSpdyClientBase::latest_response_code() const { … }

const std::string& QuicSpdyClientBase::latest_response_headers() const { … }

const std::string& QuicSpdyClientBase::preliminary_response_headers() const { … }

const HttpHeaderBlock& QuicSpdyClientBase::latest_response_header_block()
    const { … }

const std::string& QuicSpdyClientBase::latest_response_body() const { … }

const std::string& QuicSpdyClientBase::latest_response_trailers() const { … }

bool QuicSpdyClientBase::HasActiveRequests() { … }

}  // namespace quic