rtc_rtp_transceiver_impl.cc | Explore in Territory

// 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 "third_party/blink/renderer/modules/peerconnection/rtc_rtp_transceiver_impl.h"

#include "base/check_op.h"
#include "base/functional/bind.h"
#include "base/task/single_thread_task_runner.h"
#include "third_party/blink/renderer/platform/wtf/thread_safe_ref_counted.h"
#include "third_party/webrtc/api/scoped_refptr.h"

namespace blink {

RtpTransceiverState::RtpTransceiverState(
    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
    scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
    scoped_refptr<webrtc::RtpTransceiverInterface> webrtc_transceiver,
    std::optional<blink::RtpSenderState> sender_state,
    std::optional<blink::RtpReceiverState> receiver_state,
    std::optional<std::string> mid,
    webrtc::RtpTransceiverDirection direction,
    std::optional<webrtc::RtpTransceiverDirection> current_direction,
    std::optional<webrtc::RtpTransceiverDirection> fired_direction,
    WTF::Vector<webrtc::RtpHeaderExtensionCapability>
        header_extensions_negotiated)
    : … { … }

RtpTransceiverState::RtpTransceiverState(RtpTransceiverState&& other)
    : … { … }

RtpTransceiverState::~RtpTransceiverState() { … }

RtpTransceiverState& RtpTransceiverState::operator=(
    RtpTransceiverState&& other) { … }

bool RtpTransceiverState::is_initialized() const { … }

void RtpTransceiverState::Initialize() { … }

scoped_refptr<base::SingleThreadTaskRunner>
RtpTransceiverState::main_task_runner() const { … }

scoped_refptr<base::SingleThreadTaskRunner>
RtpTransceiverState::signaling_task_runner() const { … }

scoped_refptr<webrtc::RtpTransceiverInterface>
RtpTransceiverState::webrtc_transceiver() const { … }

const std::optional<blink::RtpSenderState>& RtpTransceiverState::sender_state()
    const { … }

blink::RtpSenderState RtpTransceiverState::MoveSenderState() { … }

const std::optional<blink::RtpReceiverState>&
RtpTransceiverState::receiver_state() const { … }

blink::RtpReceiverState RtpTransceiverState::MoveReceiverState() { … }

std::optional<std::string> RtpTransceiverState::mid() const { … }

webrtc::RtpTransceiverDirection RtpTransceiverState::direction() const { … }

void RtpTransceiverState::set_direction(
    webrtc::RtpTransceiverDirection direction) { … }

std::optional<webrtc::RtpTransceiverDirection>
RtpTransceiverState::current_direction() const { … }

std::optional<webrtc::RtpTransceiverDirection>
RtpTransceiverState::fired_direction() const { … }

const Vector<webrtc::RtpHeaderExtensionCapability>&
RtpTransceiverState::header_extensions_negotiated() const { … }

class RTCRtpTransceiverImpl::RTCRtpTransceiverInternal
    : public WTF::ThreadSafeRefCounted<
          RTCRtpTransceiverImpl::RTCRtpTransceiverInternal,
          RTCRtpTransceiverImpl::RTCRtpTransceiverInternalTraits> { … };

struct RTCRtpTransceiverImpl::RTCRtpTransceiverInternalTraits { … };

uintptr_t RTCRtpTransceiverImpl::GetId(
    const webrtc::RtpTransceiverInterface* webrtc_transceiver) { … }

RTCRtpTransceiverImpl::RTCRtpTransceiverImpl(
    rtc::scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
    scoped_refptr<blink::WebRtcMediaStreamTrackAdapterMap> track_map,
    RtpTransceiverState transceiver_state,
    bool encoded_insertable_streams,
    std::unique_ptr<webrtc::Metronome> decode_metronome)
    : … { … }

RTCRtpTransceiverImpl::RTCRtpTransceiverImpl(const RTCRtpTransceiverImpl& other)
    : … { … }

RTCRtpTransceiverImpl::~RTCRtpTransceiverImpl() { … }

RTCRtpTransceiverImpl& RTCRtpTransceiverImpl::operator=(
    const RTCRtpTransceiverImpl& other) { … }

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

const RtpTransceiverState& RTCRtpTransceiverImpl::state() const { … }

blink::RTCRtpSenderImpl* RTCRtpTransceiverImpl::content_sender() { … }

blink::RTCRtpReceiverImpl* RTCRtpTransceiverImpl::content_receiver() { … }

void RTCRtpTransceiverImpl::set_state(RtpTransceiverState transceiver_state,
                                      TransceiverStateUpdateMode update_mode) { … }

uintptr_t RTCRtpTransceiverImpl::Id() const { … }

String RTCRtpTransceiverImpl::Mid() const { … }

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

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

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

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

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

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

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

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

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

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

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

}  // namespace blink
chromium/third_party/blink/renderer/modules/peerconnection/rtc_rtp_transceiver_impl.cc
