proxy_resolving_client_socket.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 "services/network/proxy_resolving_client_socket.h"

#include <stdint.h>

#include <optional>
#include <string>
#include <utility>

#include "base/check_op.h"
#include "base/compiler_specific.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/notreached.h"
#include "net/base/io_buffer.h"
#include "net/base/ip_address.h"
#include "net/base/load_flags.h"
#include "net/base/net_errors.h"
#include "net/base/network_anonymization_key.h"
#include "net/base/privacy_mode.h"
#include "net/dns/public/secure_dns_policy.h"
#include "net/http/http_auth_controller.h"
#include "net/http/http_network_session.h"
#include "net/http/http_request_headers.h"
#include "net/http/proxy_client_socket.h"
#include "net/http/proxy_fallback.h"
#include "net/log/net_log_source_type.h"
#include "net/proxy_resolution/configured_proxy_resolution_service.h"
#include "net/proxy_resolution/proxy_resolution_request.h"
#include "net/socket/connect_job_factory.h"
#include "net/socket/socket_tag.h"
#include "net/traffic_annotation/network_traffic_annotation.h"

namespace network {

ProxyResolvingClientSocket::ProxyResolvingClientSocket(
    net::HttpNetworkSession* network_session,
    const net::CommonConnectJobParams* common_connect_job_params,
    const GURL& url,
    const net::NetworkAnonymizationKey& network_anonymization_key,
    bool use_tls,
    const net::ConnectJobFactory* connect_job_factory)
    : … { … }

ProxyResolvingClientSocket::~ProxyResolvingClientSocket() { … }

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

int ProxyResolvingClientSocket::ReadIfReady(
    net::IOBuffer* buf,
    int buf_len,
    net::CompletionOnceCallback callback) { … }

int ProxyResolvingClientSocket::CancelReadIfReady() { … }

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

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

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

int ProxyResolvingClientSocket::Connect(net::CompletionOnceCallback callback) { … }

void ProxyResolvingClientSocket::Disconnect() { … }

bool ProxyResolvingClientSocket::IsConnected() const { … }

bool ProxyResolvingClientSocket::IsConnectedAndIdle() const { … }

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

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

const net::NetLogWithSource& ProxyResolvingClientSocket::NetLog() const { … }

bool ProxyResolvingClientSocket::WasEverUsed() const { … }

net::NextProto ProxyResolvingClientSocket::GetNegotiatedProtocol() const { … }

bool ProxyResolvingClientSocket::GetSSLInfo(net::SSLInfo* ssl_info) { … }

int64_t ProxyResolvingClientSocket::GetTotalReceivedBytes() const { … }

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

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

int ProxyResolvingClientSocket::DoLoop(int result) { … }

int ProxyResolvingClientSocket::DoProxyResolve() { … }

int ProxyResolvingClientSocket::DoProxyResolveComplete(int result) { … }

int ProxyResolvingClientSocket::DoInitConnection() { … }

int ProxyResolvingClientSocket::DoInitConnectionComplete(int result) { … }

void ProxyResolvingClientSocket::OnConnectJobComplete(int result,
                                                      net::ConnectJob* job) { … }

void ProxyResolvingClientSocket::OnNeedsProxyAuth(
    const net::HttpResponseInfo& response,
    net::HttpAuthController* auth_controller,
    base::OnceClosure restart_with_auth_callback,
    net::ConnectJob* job) { … }

int ProxyResolvingClientSocket::ReconsiderProxyAfterError(int error) { … }

}  // namespace network
chromium/services/network/proxy_resolving_client_socket.cc
