chromium/net/third_party/quiche/src/quiche/quic/core/io/event_loop_connecting_client_socket.cc

// Copyright 2022 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/core/io/event_loop_connecting_client_socket.h"

#include <limits>
#include <string>
#include <utility>

#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
#include "absl/types/variant.h"
#include "quiche/quic/core/io/quic_event_loop.h"
#include "quiche/quic/core/io/socket.h"
#include "quiche/quic/platform/api/quic_socket_address.h"
#include "quiche/common/platform/api/quiche_logging.h"
#include "quiche/common/platform/api/quiche_mem_slice.h"

namespace quic {

EventLoopConnectingClientSocket::EventLoopConnectingClientSocket(
    socket_api::SocketProtocol protocol,
    const quic::QuicSocketAddress& peer_address,
    QuicByteCount receive_buffer_size, QuicByteCount send_buffer_size,
    QuicEventLoop* event_loop, quiche::QuicheBufferAllocator* buffer_allocator,
    AsyncVisitor* async_visitor)
    : … { … }

EventLoopConnectingClientSocket::~EventLoopConnectingClientSocket() { … }

absl::Status EventLoopConnectingClientSocket::ConnectBlocking() { … }

void EventLoopConnectingClientSocket::ConnectAsync() { … }

void EventLoopConnectingClientSocket::Disconnect() { … }

absl::StatusOr<QuicSocketAddress>
EventLoopConnectingClientSocket::GetLocalAddress() { … }

absl::StatusOr<quiche::QuicheMemSlice>
EventLoopConnectingClientSocket::ReceiveBlocking(QuicByteCount max_size) { … }

void EventLoopConnectingClientSocket::ReceiveAsync(QuicByteCount max_size) { … }

absl::Status EventLoopConnectingClientSocket::SendBlocking(std::string data) { … }

absl::Status EventLoopConnectingClientSocket::SendBlocking(
    quiche::QuicheMemSlice data) { … }

void EventLoopConnectingClientSocket::SendAsync(std::string data) { … }

void EventLoopConnectingClientSocket::SendAsync(quiche::QuicheMemSlice data) { … }

void EventLoopConnectingClientSocket::OnSocketEvent(
    QuicEventLoop* event_loop, SocketFd fd, QuicSocketEventMask events) { … }

absl::Status EventLoopConnectingClientSocket::Open() { … }

void EventLoopConnectingClientSocket::Close() { … }

absl::Status EventLoopConnectingClientSocket::DoInitialConnect() { … }

absl::Status EventLoopConnectingClientSocket::GetConnectResult() { … }

void EventLoopConnectingClientSocket::FinishOrRearmAsyncConnect(
    absl::Status status) { … }

absl::StatusOr<quiche::QuicheMemSlice>
EventLoopConnectingClientSocket::ReceiveInternal() { … }

void EventLoopConnectingClientSocket::FinishOrRearmAsyncReceive(
    absl::StatusOr<quiche::QuicheMemSlice> buffer) { … }

absl::StatusOr<bool> EventLoopConnectingClientSocket::OneBytePeek() { … }

absl::Status EventLoopConnectingClientSocket::SendBlockingInternal() { … }

absl::Status EventLoopConnectingClientSocket::SendInternal() { … }

void EventLoopConnectingClientSocket::FinishOrRearmAsyncSend(
    absl::Status status) { … }

}  // namespace quic