chromium/third_party/webrtc/call/fake_network_pipe.cc

/*
 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "call/fake_network_pipe.h"

#include <string.h>

#include <algorithm>
#include <queue>
#include <utility>
#include <vector>

#include "api/media_types.h"
#include "api/units/timestamp.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "system_wrappers/include/clock.h"

namespace webrtc {

namespace {
constexpr int64_t kLogIntervalMs = …;
}  // namespace

NetworkPacket::NetworkPacket(rtc::CopyOnWriteBuffer packet,
                             int64_t send_time,
                             int64_t arrival_time,
                             absl::optional<PacketOptions> packet_options,
                             bool is_rtcp,
                             MediaType media_type,
                             absl::optional<int64_t> packet_time_us,
                             Transport* transport)
    : … { … }

NetworkPacket::NetworkPacket(RtpPacketReceived packet_received,
                             MediaType media_type,
                             int64_t send_time,
                             int64_t arrival_time)
    : … { … }

NetworkPacket::NetworkPacket(NetworkPacket&& o)
    : … { … }

NetworkPacket::~NetworkPacket() = default;

NetworkPacket& NetworkPacket::operator=(NetworkPacket&& o) { … }

FakeNetworkPipe::FakeNetworkPipe(
    Clock* clock,
    std::unique_ptr<NetworkBehaviorInterface> network_behavior)
    : … { … }

FakeNetworkPipe::FakeNetworkPipe(
    Clock* clock,
    std::unique_ptr<NetworkBehaviorInterface> network_behavior,
    PacketReceiver* receiver)
    : … { … }

FakeNetworkPipe::FakeNetworkPipe(
    Clock* clock,
    std::unique_ptr<NetworkBehaviorInterface> network_behavior,
    PacketReceiver* receiver,
    uint64_t seed)
    : … { … }

FakeNetworkPipe::~FakeNetworkPipe() { … }

void FakeNetworkPipe::SetReceiver(PacketReceiver* receiver) { … }

void FakeNetworkPipe::AddActiveTransport(Transport* transport) { … }

void FakeNetworkPipe::RemoveActiveTransport(Transport* transport) { … }

bool FakeNetworkPipe::SendRtp(rtc::ArrayView<const uint8_t> packet,
                              const PacketOptions& options,
                              Transport* transport) { … }

bool FakeNetworkPipe::SendRtcp(rtc::ArrayView<const uint8_t> packet,
                               Transport* transport) { … }

void FakeNetworkPipe::DeliverRtpPacket(
    MediaType media_type,
    RtpPacketReceived packet,
    OnUndemuxablePacketHandler undemuxable_packet_handler) { … }

void FakeNetworkPipe::DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) { … }

void FakeNetworkPipe::SetClockOffset(int64_t offset_ms) { … }

FakeNetworkPipe::StoredPacket::StoredPacket(NetworkPacket&& packet)
    : … { … }

bool FakeNetworkPipe::EnqueuePacket(rtc::CopyOnWriteBuffer packet,
                                    absl::optional<PacketOptions> options,
                                    bool is_rtcp,
                                    MediaType media_type,
                                    absl::optional<int64_t> packet_time_us) { … }

bool FakeNetworkPipe::EnqueuePacket(rtc::CopyOnWriteBuffer packet,
                                    absl::optional<PacketOptions> options,
                                    bool is_rtcp,
                                    Transport* transport) { … }

bool FakeNetworkPipe::EnqueuePacket(NetworkPacket&& net_packet) { … }

float FakeNetworkPipe::PercentageLoss() { … }

int FakeNetworkPipe::AverageDelay() { … }

size_t FakeNetworkPipe::DroppedPackets() { … }

size_t FakeNetworkPipe::SentPackets() { … }

void FakeNetworkPipe::Process() { … }

void FakeNetworkPipe::DeliverNetworkPacket(NetworkPacket* packet) { … }

absl::optional<int64_t> FakeNetworkPipe::TimeUntilNextProcess() { … }

bool FakeNetworkPipe::HasReceiver() const { … }

void FakeNetworkPipe::DeliverPacketWithLock(NetworkPacket* packet) { … }

void FakeNetworkPipe::ResetStats() { … }

int64_t FakeNetworkPipe::GetTimeInMicroseconds() const { … }

}  // namespace webrtc