chromium_socket_factory.cc | Explore in Territory

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "remoting/protocol/chromium_socket_factory.h"

#include <stddef.h>

#include <list>
#include <memory>
#include <string>

#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/rand_util.h"
#include "base/time/time.h"
#include "components/webrtc/net_address_utils.h"
#include "net/base/io_buffer.h"
#include "net/base/ip_endpoint.h"
#include "net/base/net_errors.h"
#include "net/log/net_log_source.h"
#include "net/socket/udp_server_socket.h"
#include "remoting/base/logging.h"
#include "remoting/base/session_options.h"
#include "remoting/protocol/session_options_provider.h"
#include "remoting/protocol/socket_util.h"
#include "remoting/protocol/stream_packet_socket.h"
#include "third_party/webrtc/api/units/timestamp.h"
#include "third_party/webrtc/media/base/rtp_utils.h"
#include "third_party/webrtc/rtc_base/async_dns_resolver.h"
#include "third_party/webrtc/rtc_base/async_packet_socket.h"
#include "third_party/webrtc/rtc_base/net_helpers.h"
#include "third_party/webrtc/rtc_base/network/received_packet.h"
#include "third_party/webrtc/rtc_base/socket.h"

namespace remoting::protocol {

namespace {

// Size of the buffer to allocate for RecvFrom().
const int kReceiveBufferSize = …;

// Maximum amount of data in the send buffers. This is necessary to
// prevent out-of-memory crashes if the caller sends data faster than
// Pepper's UDP API can handle it. This maximum should never be
// reached under normal conditions.
const int kMaxSendBufferSize = …;

// Creates a UDP socket and make it listen at |local_address| and |port|.
// Returns nullptr if the socket fails to listen.
std::unique_ptr<net::UDPServerSocket> CreateUdpSocketAndListen(
    const net::IPAddress& local_address,
    uint16_t port) { … }

class UdpPacketSocket : public rtc::AsyncPacketSocket { … };

UdpPacketSocket::PendingPacket::PendingPacket(const void* buffer,
                                              int buffer_size,
                                              const net::IPEndPoint& address,
                                              const rtc::PacketOptions& options)
    : … { … }

UdpPacketSocket::UdpPacketSocket() = default;

UdpPacketSocket::~UdpPacketSocket() { … }

bool UdpPacketSocket::Init(const rtc::SocketAddress& local_address,
                           uint16_t min_port,
                           uint16_t max_port) { … }

rtc::SocketAddress UdpPacketSocket::GetLocalAddress() const { … }

rtc::SocketAddress UdpPacketSocket::GetRemoteAddress() const { … }

int UdpPacketSocket::Send(const void* data,
                          size_t data_size,
                          const rtc::PacketOptions& options) { … }

int UdpPacketSocket::SendTo(const void* data,
                            size_t data_size,
                            const rtc::SocketAddress& address,
                            const rtc::PacketOptions& options) { … }

int UdpPacketSocket::Close() { … }

rtc::AsyncPacketSocket::State UdpPacketSocket::GetState() const { … }

int UdpPacketSocket::GetOption(rtc::Socket::Option option, int* value) { … }

int UdpPacketSocket::SetOption(rtc::Socket::Option option, int value) { … }

int UdpPacketSocket::GetError() const { … }

void UdpPacketSocket::SetError(int error) { … }

void UdpPacketSocket::DoSend() { … }

void UdpPacketSocket::OnSendCompleted(int result) { … }

void UdpPacketSocket::DoRead() { … }

void UdpPacketSocket::OnReadCompleted(int result) { … }

void UdpPacketSocket::HandleReadResult(int result) { … }

}  // namespace

ChromiumPacketSocketFactory::ChromiumPacketSocketFactory(
    base::WeakPtr<SessionOptionsProvider> session_options_provider)
    : … { … }

ChromiumPacketSocketFactory::~ChromiumPacketSocketFactory() = default;

rtc::AsyncPacketSocket* ChromiumPacketSocketFactory::CreateUdpSocket(
    const rtc::SocketAddress& local_address,
    uint16_t min_port,
    uint16_t max_port) { … }

rtc::AsyncListenSocket* ChromiumPacketSocketFactory::CreateServerTcpSocket(
    const rtc::SocketAddress& local_address,
    uint16_t min_port,
    uint16_t max_port,
    int opts) { … }

rtc::AsyncPacketSocket* ChromiumPacketSocketFactory::CreateClientTcpSocket(
    const rtc::SocketAddress& local_address,
    const rtc::SocketAddress& remote_address,
    const rtc::PacketSocketTcpOptions& opts) { … }

std::unique_ptr<webrtc::AsyncDnsResolverInterface>
ChromiumPacketSocketFactory::CreateAsyncDnsResolver() { … }

}  // namespace remoting::protocol
chromium/remoting/protocol/chromium_socket_factory.cc
