quic_proxy_client_socket.cc | Explore in Territory

// Copyright 2017 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_proxy_client_socket.h"

#include <cstdio>
#include <string_view>
#include <utility>

#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/values.h"
#include "net/base/proxy_chain.h"
#include "net/base/proxy_delegate.h"
#include "net/http/http_auth_controller.h"
#include "net/http/http_log_util.h"
#include "net/http/http_response_headers.h"
#include "net/log/net_log_source.h"
#include "net/log/net_log_source_type.h"
#include "net/quic/quic_http_utils.h"
#include "net/spdy/spdy_http_utils.h"
#include "net/traffic_annotation/network_traffic_annotation.h"

namespace net {

QuicProxyClientSocket::QuicProxyClientSocket(
    std::unique_ptr<QuicChromiumClientStream::Handle> stream,
    std::unique_ptr<QuicChromiumClientSession::Handle> session,
    const ProxyChain& proxy_chain,
    size_t proxy_chain_index,
    const std::string& user_agent,
    const HostPortPair& endpoint,
    const NetLogWithSource& net_log,
    scoped_refptr<HttpAuthController> auth_controller,
    ProxyDelegate* proxy_delegate)
    : … { … }

QuicProxyClientSocket::~QuicProxyClientSocket() { … }

const HttpResponseInfo* QuicProxyClientSocket::GetConnectResponseInfo() const { … }

const scoped_refptr<HttpAuthController>&
QuicProxyClientSocket::GetAuthController() const { … }

int QuicProxyClientSocket::RestartWithAuth(CompletionOnceCallback callback) { … }

// Ignore priority changes, just use priority of initial request. Since multiple
// requests are pooled on the QuicProxyClientSocket, reprioritization doesn't
// really work.
//
// TODO(mmenke):  Use a single priority value for all QuicProxyClientSockets,
// regardless of what priority they're created with.
void QuicProxyClientSocket::SetStreamPriority(RequestPriority priority) { … }

// Sends a HEADERS frame to the proxy with a CONNECT request
// for the specified endpoint.  Waits for the server to send back
// a HEADERS frame.  OK will be returned if the status is 200.
// ERR_TUNNEL_CONNECTION_FAILED will be returned for any other status.
// In any of these cases, Read() may be called to retrieve the HTTP
// response body.  Any other return values should be considered fatal.
int QuicProxyClientSocket::Connect(CompletionOnceCallback callback) { … }

void QuicProxyClientSocket::Disconnect() { … }

bool QuicProxyClientSocket::IsConnected() const { … }

bool QuicProxyClientSocket::IsConnectedAndIdle() const { … }

const NetLogWithSource& QuicProxyClientSocket::NetLog() const { … }

bool QuicProxyClientSocket::WasEverUsed() const { … }

NextProto QuicProxyClientSocket::GetNegotiatedProtocol() const { … }

bool QuicProxyClientSocket::GetSSLInfo(SSLInfo* ssl_info) { … }

int64_t QuicProxyClientSocket::GetTotalReceivedBytes() const { … }

void QuicProxyClientSocket::ApplySocketTag(const SocketTag& tag) { … }

int QuicProxyClientSocket::Read(IOBuffer* buf,
                                int buf_len,
                                CompletionOnceCallback callback) { … }

void QuicProxyClientSocket::OnReadComplete(int rv) { … }

int QuicProxyClientSocket::Write(
    IOBuffer* buf,
    int buf_len,
    CompletionOnceCallback callback,
    const NetworkTrafficAnnotationTag& traffic_annotation) { … }

void QuicProxyClientSocket::OnWriteComplete(int rv) { … }

int QuicProxyClientSocket::SetReceiveBufferSize(int32_t size) { … }

int QuicProxyClientSocket::SetSendBufferSize(int32_t size) { … }

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

int QuicProxyClientSocket::GetLocalAddress(IPEndPoint* address) const { … }

void QuicProxyClientSocket::OnIOComplete(int result) { … }

int QuicProxyClientSocket::DoLoop(int last_io_result) { … }

int QuicProxyClientSocket::DoGenerateAuthToken() { … }

int QuicProxyClientSocket::DoGenerateAuthTokenComplete(int result) { … }

int QuicProxyClientSocket::DoSendRequest() { … }

int QuicProxyClientSocket::DoSendRequestComplete(int result) { … }

int QuicProxyClientSocket::DoReadReply() { … }

int QuicProxyClientSocket::DoReadReplyComplete(int result) { … }

void QuicProxyClientSocket::OnReadResponseHeadersComplete(int result) { … }

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

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