quic_http_stream.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.

#include "net/quic/quic_http_stream.h"

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

#include "base/auto_reset.h"
#include "base/functional/bind.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/string_split.h"
#include "base/task/single_thread_task_runner.h"
#include "net/base/features.h"
#include "net/base/ip_endpoint.h"
#include "net/base/load_flags.h"
#include "net/base/net_errors.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_status_code.h"
#include "net/http/http_util.h"
#include "net/log/net_log.h"
#include "net/log/net_log_event_type.h"
#include "net/log/net_log_source.h"
#include "net/quic/quic_http_utils.h"
#include "net/spdy/spdy_http_utils.h"
#include "net/ssl/ssl_info.h"
#include "net/third_party/quiche/src/quiche/quic/core/http/spdy_utils.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_stream_sequencer.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quiche/spdy/core/spdy_frame_builder.h"
#include "net/third_party/quiche/src/quiche/spdy/core/spdy_framer.h"
#include "url/origin.h"
#include "url/scheme_host_port.h"

namespace net {

QuicHttpStream::QuicHttpStream(
    std::unique_ptr<QuicChromiumClientSession::Handle> session,
    std::set<std::string> dns_aliases)
    : … { … }

QuicHttpStream::~QuicHttpStream() { … }

HttpConnectionInfo QuicHttpStream::ConnectionInfoFromQuicVersion(
    quic::ParsedQuicVersion quic_version) { … }

void QuicHttpStream::RegisterRequest(const HttpRequestInfo* request_info) { … }

int QuicHttpStream::InitializeStream(bool can_send_early,
                                     RequestPriority priority,
                                     const NetLogWithSource& stream_net_log,
                                     CompletionOnceCallback callback) { … }

int QuicHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
                                HttpResponseInfo* response,
                                CompletionOnceCallback callback) { … }

int QuicHttpStream::ReadResponseHeaders(CompletionOnceCallback callback) { … }

int QuicHttpStream::ReadResponseBody(IOBuffer* buf,
                                     int buf_len,
                                     CompletionOnceCallback callback) { … }

void QuicHttpStream::Close(bool /*not_reusable*/) { … }

bool QuicHttpStream::IsResponseBodyComplete() const { … }

bool QuicHttpStream::IsConnectionReused() const { … }

int64_t QuicHttpStream::GetTotalReceivedBytes() const { … }

int64_t QuicHttpStream::GetTotalSentBytes() const { … }

bool QuicHttpStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const { … }

bool QuicHttpStream::GetAlternativeService(
    AlternativeService* alternative_service) const { … }

void QuicHttpStream::PopulateNetErrorDetails(NetErrorDetails* details) { … }

void QuicHttpStream::SetPriority(RequestPriority priority) { … }

void QuicHttpStream::OnReadResponseHeadersComplete(int rv) { … }

const std::set<std::string>& QuicHttpStream::GetDnsAliases() const { … }

std::string_view QuicHttpStream::GetAcceptChViaAlps() const { … }

std::optional<HttpStream::QuicErrorDetails>
QuicHttpStream::GetQuicErrorDetails() const { … }

void QuicHttpStream::ReadTrailingHeaders() { … }

void QuicHttpStream::OnReadTrailingHeadersComplete(int rv) { … }

void QuicHttpStream::OnIOComplete(int rv) { … }

void QuicHttpStream::DoCallback(int rv) { … }

int QuicHttpStream::DoLoop(int rv) { … }

int QuicHttpStream::DoRequestStream() { … }

int QuicHttpStream::DoRequestStreamComplete(int rv) { … }

int QuicHttpStream::DoSetRequestPriority() { … }

int QuicHttpStream::DoSendHeaders() { … }

int QuicHttpStream::DoSendHeadersComplete(int rv) { … }

int QuicHttpStream::DoReadRequestBody() { … }

int QuicHttpStream::DoReadRequestBodyComplete(int rv) { … }

int QuicHttpStream::DoSendBody() { … }

int QuicHttpStream::DoSendBodyComplete(int rv) { … }

int QuicHttpStream::ProcessResponseHeaders(
    const quiche::HttpHeaderBlock& headers) { … }

void QuicHttpStream::OnReadBodyComplete(int rv) { … }

int QuicHttpStream::HandleReadComplete(int rv) { … }

void QuicHttpStream::ResetStream() { … }

int QuicHttpStream::MapStreamError(int rv) { … }

int QuicHttpStream::GetResponseStatus() { … }

void QuicHttpStream::SaveResponseStatus() { … }

void QuicHttpStream::SetResponseStatus(int response_status) { … }

int QuicHttpStream::ComputeResponseStatus() const { … }

void QuicHttpStream::SetRequestIdempotency(Idempotency idempotency) { … }

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