chromium/net/http/http_stream_pool_group.cc

// Copyright 2024 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/http/http_stream_pool_group.h"

#include "base/types/expected.h"
#include "net/base/completion_once_callback.h"
#include "net/base/load_timing_info.h"
#include "net/base/net_errors.h"
#include "net/http/http_basic_stream.h"
#include "net/http/http_network_session.h"
#include "net/http/http_stream.h"
#include "net/http/http_stream_key.h"
#include "net/http/http_stream_pool_attempt_manager.h"
#include "net/http/http_stream_pool_handle.h"
#include "net/log/net_log_event_type.h"
#include "net/socket/next_proto.h"
#include "net/socket/stream_socket.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_versions.h"

namespace net {

namespace {

bool IsNegotiatedProtocolTextBased(NextProto next_proto) { … }

void RecordNetLogClosingSocket(const StreamSocket& stream_socket,
                               std::string_view reason) { … }

}  // namespace

// static
base::expected<void, std::string_view>
HttpStreamPool::Group::IsIdleStreamSocketUsable(const IdleStreamSocket& idle) { … }

HttpStreamPool::Group::IdleStreamSocket::IdleStreamSocket(
    std::unique_ptr<StreamSocket> stream_socket,
    base::TimeTicks time_became_idle)
    : … { … }

HttpStreamPool::Group::IdleStreamSocket::~IdleStreamSocket() = default;

HttpStreamPool::Group::Group(HttpStreamPool* pool,
                             HttpStreamKey stream_key,
                             SpdySessionKey spdy_session_key)
    : … { … }

HttpStreamPool::Group::~Group() { … }

std::unique_ptr<HttpStreamPool::Job> HttpStreamPool::Group::StartJob(
    Job::Delegate* delegate,
    RequestPriority priority,
    const std::vector<SSLConfig::CertAndStatus>& allowed_bad_certs,
    bool enable_ip_based_pooling,
    bool enable_alternative_services,
    quic::ParsedQuicVersion quic_version,
    const NetLogWithSource& net_log) { … }

int HttpStreamPool::Group::Preconnect(size_t num_streams,
                                      quic::ParsedQuicVersion quic_version,
                                      CompletionOnceCallback callback) { … }

std::unique_ptr<HttpStreamPoolHandle> HttpStreamPool::Group::CreateHandle(
    std::unique_ptr<StreamSocket> socket,
    StreamSocketHandle::SocketReuseType reuse_type,
    LoadTimingInfo::ConnectTiming connect_timing) { … }

std::unique_ptr<HttpStream> HttpStreamPool::Group::CreateTextBasedStream(
    std::unique_ptr<StreamSocket> socket,
    StreamSocketHandle::SocketReuseType reuse_type,
    LoadTimingInfo::ConnectTiming connect_timing) { … }

void HttpStreamPool::Group::ReleaseStreamSocket(
    std::unique_ptr<StreamSocket> socket,
    int64_t generation) { … }

void HttpStreamPool::Group::AddIdleStreamSocket(
    std::unique_ptr<StreamSocket> socket) { … }

std::unique_ptr<StreamSocket> HttpStreamPool::Group::GetIdleStreamSocket() { … }

void HttpStreamPool::Group::ProcessPendingRequest() { … }

bool HttpStreamPool::Group::CloseOneIdleStreamSocket() { … }

size_t HttpStreamPool::Group::ActiveStreamSocketCount() const { … }

bool HttpStreamPool::Group::ReachedMaxStreamLimit() const { … }

std::optional<RequestPriority>
HttpStreamPool::Group::GetPriorityIfStalledByPoolLimit() const { … }

void HttpStreamPool::Group::Refresh(
    std::string_view net_log_close_reason_utf8) { … }

void HttpStreamPool::Group::CloseIdleStreams(
    std::string_view net_log_close_reason_utf8) { … }

void HttpStreamPool::Group::CancelJobs(int error) { … }

void HttpStreamPool::Group::OnRequiredHttp11() { … }

void HttpStreamPool::Group::OnAttemptManagerComplete() { … }

base::Value::Dict HttpStreamPool::Group::GetInfoAsValue() const { … }

void HttpStreamPool::Group::CleanupTimedoutIdleStreamSocketsForTesting() { … }

void HttpStreamPool::Group::MaybeUpdateQuicVersionWhenForced(
    quic::ParsedQuicVersion& quic_version) { … }

void HttpStreamPool::Group::CleanupIdleStreamSockets(
    CleanupMode mode,
    std::string_view net_log_close_reason_utf8) { … }

void HttpStreamPool::Group::EnsureAttemptManager() { … }

void HttpStreamPool::Group::MaybeComplete() { … }

}  // namespace net