chromium/third_party/blink/renderer/modules/peerconnection/fake_rtc_rtp_transceiver_impl.cc

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

#include <utility>

#include "base/task/single_thread_task_runner.h"
#include "third_party/blink/renderer/modules/peerconnection/fake_rtc_rtp_transceiver_impl.h"
#include "third_party/blink/renderer/platform/mediastream/media_stream_audio_track.h"
#include "third_party/blink/renderer/platform/mediastream/media_stream_component_impl.h"
#include "third_party/blink/renderer/platform/mediastream/media_stream_source.h"
#include "third_party/blink/renderer/platform/peerconnection/rtc_dtmf_sender_handler.h"

namespace blink {

MediaStreamComponent* CreateMediaStreamComponent(
    const String& id,
    scoped_refptr<base::SingleThreadTaskRunner> task_runner) { … }

FakeRTCRtpSenderImpl::FakeRTCRtpSenderImpl(
    std::optional<String> track_id,
    Vector<String> stream_ids,
    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
    : … { … }

FakeRTCRtpSenderImpl::FakeRTCRtpSenderImpl(const FakeRTCRtpSenderImpl&) =
    default;

FakeRTCRtpSenderImpl::~FakeRTCRtpSenderImpl() { … }

FakeRTCRtpSenderImpl& FakeRTCRtpSenderImpl::operator=(
    const FakeRTCRtpSenderImpl&) = default;

std::unique_ptr<blink::RTCRtpSenderPlatform> FakeRTCRtpSenderImpl::ShallowCopy()
    const { … }

uintptr_t FakeRTCRtpSenderImpl::Id() const { … }

rtc::scoped_refptr<webrtc::DtlsTransportInterface>
FakeRTCRtpSenderImpl::DtlsTransport() { … }

webrtc::DtlsTransportInformation
FakeRTCRtpSenderImpl::DtlsTransportInformation() { … }

MediaStreamComponent* FakeRTCRtpSenderImpl::Track() const { … }

Vector<String> FakeRTCRtpSenderImpl::StreamIds() const { … }

void FakeRTCRtpSenderImpl::ReplaceTrack(MediaStreamComponent* with_track,
                                        RTCVoidRequest* request) { … }

std::unique_ptr<blink::RtcDtmfSenderHandler>
FakeRTCRtpSenderImpl::GetDtmfSender() const { … }

std::unique_ptr<webrtc::RtpParameters> FakeRTCRtpSenderImpl::GetParameters()
    const { … }

void FakeRTCRtpSenderImpl::SetParameters(
    Vector<webrtc::RtpEncodingParameters>,
    std::optional<webrtc::DegradationPreference>,
    blink::RTCVoidRequest*) { … }

void FakeRTCRtpSenderImpl::GetStats(RTCStatsReportCallback) { … }

void FakeRTCRtpSenderImpl::SetStreams(const Vector<String>& stream_ids) { … }

FakeRTCRtpReceiverImpl::FakeRTCRtpReceiverImpl(
    const String& track_id,
    Vector<String> stream_ids,
    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
    : … { … }

FakeRTCRtpReceiverImpl::FakeRTCRtpReceiverImpl(const FakeRTCRtpReceiverImpl&) =
    default;

FakeRTCRtpReceiverImpl::~FakeRTCRtpReceiverImpl() { … }

FakeRTCRtpReceiverImpl& FakeRTCRtpReceiverImpl::operator=(
    const FakeRTCRtpReceiverImpl&) = default;

std::unique_ptr<RTCRtpReceiverPlatform> FakeRTCRtpReceiverImpl::ShallowCopy()
    const { … }

uintptr_t FakeRTCRtpReceiverImpl::Id() const { … }

rtc::scoped_refptr<webrtc::DtlsTransportInterface>
FakeRTCRtpReceiverImpl::DtlsTransport() { … }

webrtc::DtlsTransportInformation
FakeRTCRtpReceiverImpl::DtlsTransportInformation() { … }

MediaStreamComponent* FakeRTCRtpReceiverImpl::Track() const { … }

Vector<String> FakeRTCRtpReceiverImpl::StreamIds() const { … }

Vector<std::unique_ptr<RTCRtpSource>> FakeRTCRtpReceiverImpl::GetSources() { … }

void FakeRTCRtpReceiverImpl::GetStats(RTCStatsReportCallback) { … }

std::unique_ptr<webrtc::RtpParameters> FakeRTCRtpReceiverImpl::GetParameters()
    const { … }

void FakeRTCRtpReceiverImpl::SetJitterBufferMinimumDelay(
    std::optional<double> delay_seconds) { … }

FakeRTCRtpTransceiverImpl::FakeRTCRtpTransceiverImpl(
    const String& mid,
    FakeRTCRtpSenderImpl sender,
    FakeRTCRtpReceiverImpl receiver,
    webrtc::RtpTransceiverDirection direction,
    std::optional<webrtc::RtpTransceiverDirection> current_direction)
    : … { … }

FakeRTCRtpTransceiverImpl::~FakeRTCRtpTransceiverImpl() { … }

uintptr_t FakeRTCRtpTransceiverImpl::Id() const { … }

String FakeRTCRtpTransceiverImpl::Mid() const { … }

std::unique_ptr<blink::RTCRtpSenderPlatform> FakeRTCRtpTransceiverImpl::Sender()
    const { … }

std::unique_ptr<RTCRtpReceiverPlatform> FakeRTCRtpTransceiverImpl::Receiver()
    const { … }

webrtc::RtpTransceiverDirection FakeRTCRtpTransceiverImpl::Direction() const { … }

webrtc::RTCError FakeRTCRtpTransceiverImpl::SetDirection(
    webrtc::RtpTransceiverDirection direction) { … }

std::optional<webrtc::RtpTransceiverDirection>
FakeRTCRtpTransceiverImpl::CurrentDirection() const { … }

std::optional<webrtc::RtpTransceiverDirection>
FakeRTCRtpTransceiverImpl::FiredDirection() const { … }

webrtc::RTCError FakeRTCRtpTransceiverImpl::Stop() { … }

webrtc::RTCError FakeRTCRtpTransceiverImpl::SetCodecPreferences(
    Vector<webrtc::RtpCodecCapability>) { … }

webrtc::RTCError FakeRTCRtpTransceiverImpl::SetHeaderExtensionsToNegotiate(
    Vector<webrtc::RtpHeaderExtensionCapability> header_extensions) { … }

Vector<webrtc::RtpHeaderExtensionCapability>
FakeRTCRtpTransceiverImpl::GetNegotiatedHeaderExtensions() const { … }

Vector<webrtc::RtpHeaderExtensionCapability>
FakeRTCRtpTransceiverImpl::GetHeaderExtensionsToNegotiate() const { … }

}  // namespace blink