chromium/third_party/webrtc/pc/peer_connection.cc

/*
 *  Copyright 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 "pc/peer_connection.h"

#include <limits.h>
#include <stddef.h>

#include <algorithm>
#include <memory>
#include <set>
#include <string>
#include <utility>

#include "absl/algorithm/container.h"
#include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "api/environment/environment.h"
#include "api/jsep_ice_candidate.h"
#include "api/media_types.h"
#include "api/rtp_parameters.h"
#include "api/rtp_transceiver_direction.h"
#include "api/uma_metrics.h"
#include "api/video/video_codec_constants.h"
#include "call/audio_state.h"
#include "call/packet_receiver.h"
#include "media/base/media_channel.h"
#include "media/base/media_config.h"
#include "media/base/media_engine.h"
#include "media/base/rid_description.h"
#include "media/base/stream_params.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "p2p/base/basic_async_resolver_factory.h"
#include "p2p/base/connection.h"
#include "p2p/base/connection_info.h"
#include "p2p/base/dtls_transport_internal.h"
#include "p2p/base/p2p_constants.h"
#include "p2p/base/p2p_transport_channel.h"
#include "p2p/base/transport_info.h"
#include "pc/ice_server_parsing.h"
#include "pc/rtp_receiver.h"
#include "pc/rtp_receiver_proxy.h"
#include "pc/rtp_sender.h"
#include "pc/rtp_sender_proxy.h"
#include "pc/sctp_transport.h"
#include "pc/simulcast_description.h"
#include "pc/webrtc_session_description_factory.h"
#include "rtc_base/crypto_random.h"
#include "rtc_base/ip_address.h"
#include "rtc_base/logging.h"
#include "rtc_base/net_helper.h"
#include "rtc_base/network.h"
#include "rtc_base/network_constants.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/string_encode.h"
#include "rtc_base/trace_event.h"
#include "rtc_base/unique_id_generator.h"
#include "system_wrappers/include/metrics.h"

ContentInfo;
ContentInfos;
MediaContentDescription;
MediaProtocolType;
RidDescription;
RidDirection;
SessionDescription;
SimulcastDescription;
SimulcastLayer;
SimulcastLayerList;
StreamParams;
TransportInfo;

namespace webrtc {

namespace {

static const int REPORT_USAGE_PATTERN_DELAY_MS = …;

uint32_t ConvertIceTransportTypeToCandidateFilter(
    PeerConnectionInterface::IceTransportsType type) { … }

IceCandidatePairType GetIceCandidatePairCounter(
    const cricket::Candidate& local,
    const cricket::Candidate& remote) { … }

absl::optional<int> RTCConfigurationToIceConfigOptionalInt(
    int rtc_configuration_parameter) { … }

// Check if the changes of IceTransportsType motives an ice restart.
bool NeedIceRestart(bool surface_ice_candidates_on_ice_transport_type_changed,
                    PeerConnectionInterface::IceTransportsType current,
                    PeerConnectionInterface::IceTransportsType modified) { … }

cricket::IceConfig ParseIceConfig(
    const PeerConnectionInterface::RTCConfiguration& config) { … }

// Ensures the configuration doesn't have any parameters with invalid values,
// or values that conflict with other parameters.
//
// Returns RTCError::OK() if there are no issues.
RTCError ValidateConfiguration(
    const PeerConnectionInterface::RTCConfiguration& config) { … }

// Checks for valid pool size range and if a previous value has already been
// set, which is done via SetLocalDescription.
RTCError ValidateIceCandidatePoolSize(
    int ice_candidate_pool_size,
    absl::optional<int> previous_ice_candidate_pool_size) { … }

// The simplest (and most future-compatible) way to tell if a config was
// modified in an invalid way is to copy each property we do support modifying,
// then use operator==. There are far more properties we don't support modifying
// than those we do, and more could be added.
// This helper function accepts a proposed new `configuration` object, an
// existing configuration and returns a valid, modified, configuration that's
// based on the existing configuration, with modified properties copied from
// `configuration`.
// If the result of creating a modified configuration doesn't pass the above
// `operator==` test or a call to `ValidateConfiguration()`, then the function
// will return an error. Otherwise, the return value will be the new config.
RTCErrorOr<PeerConnectionInterface::RTCConfiguration> ApplyConfiguration(
    const PeerConnectionInterface::RTCConfiguration& configuration,
    const PeerConnectionInterface::RTCConfiguration& existing_configuration) { … }

bool HasRtcpMuxEnabled(const cricket::ContentInfo* content) { … }

bool DtlsEnabled(const PeerConnectionInterface::RTCConfiguration& configuration,
                 const PeerConnectionFactoryInterface::Options& options,
                 const PeerConnectionDependencies& dependencies) { … }

// Calls `ParseIceServersOrError` to extract ice server information from the
// `configuration` and then validates the extracted configuration. For a
// non-empty list of servers, usage gets recorded via `usage_pattern`.
RTCError ParseAndValidateIceServersFromConfiguration(
    const PeerConnectionInterface::RTCConfiguration& configuration,
    cricket::ServerAddresses& stun_servers,
    std::vector<cricket::RelayServerConfig>& turn_servers,
    UsagePattern& usage_pattern) { … }

}  // namespace

bool PeerConnectionInterface::RTCConfiguration::operator==(
    const PeerConnectionInterface::RTCConfiguration& o) const { … }

bool PeerConnectionInterface::RTCConfiguration::operator!=(
    const PeerConnectionInterface::RTCConfiguration& o) const { … }

RTCErrorOr<rtc::scoped_refptr<PeerConnection>> PeerConnection::Create(
    const Environment& env,
    rtc::scoped_refptr<ConnectionContext> context,
    const PeerConnectionFactoryInterface::Options& options,
    std::unique_ptr<Call> call,
    const PeerConnectionInterface::RTCConfiguration& configuration,
    PeerConnectionDependencies dependencies) { … }

PeerConnection::PeerConnection(
    const Environment& env,
    rtc::scoped_refptr<ConnectionContext> context,
    const PeerConnectionFactoryInterface::Options& options,
    bool is_unified_plan,
    std::unique_ptr<Call> call,
    PeerConnectionDependencies& dependencies,
    bool dtls_enabled)
    : … { … }

PeerConnection::~PeerConnection() { … }

RTCError PeerConnection::Initialize(
    const PeerConnectionInterface::RTCConfiguration& configuration,
    PeerConnectionDependencies dependencies) { … }

JsepTransportController* PeerConnection::InitializeTransportController_n(
    const RTCConfiguration& configuration,
    const PeerConnectionDependencies& dependencies) { … }

rtc::scoped_refptr<StreamCollectionInterface> PeerConnection::local_streams() { … }

rtc::scoped_refptr<StreamCollectionInterface> PeerConnection::remote_streams() { … }

bool PeerConnection::AddStream(MediaStreamInterface* local_stream) { … }

void PeerConnection::RemoveStream(MediaStreamInterface* local_stream) { … }

RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
    rtc::scoped_refptr<MediaStreamTrackInterface> track,
    const std::vector<std::string>& stream_ids) { … }

RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
    rtc::scoped_refptr<MediaStreamTrackInterface> track,
    const std::vector<std::string>& stream_ids,
    const std::vector<RtpEncodingParameters>& init_send_encodings) { … }

RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack(
    rtc::scoped_refptr<MediaStreamTrackInterface> track,
    const std::vector<std::string>& stream_ids,
    const std::vector<RtpEncodingParameters>* init_send_encodings) { … }

RTCError PeerConnection::RemoveTrackOrError(
    rtc::scoped_refptr<RtpSenderInterface> sender) { … }

rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
PeerConnection::FindTransceiverBySender(
    rtc::scoped_refptr<RtpSenderInterface> sender) { … }

RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
PeerConnection::AddTransceiver(
    rtc::scoped_refptr<MediaStreamTrackInterface> track) { … }

RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
PeerConnection::AddTransceiver(
    rtc::scoped_refptr<MediaStreamTrackInterface> track,
    const RtpTransceiverInit& init) { … }

RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
PeerConnection::AddTransceiver(cricket::MediaType media_type) { … }

RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
PeerConnection::AddTransceiver(cricket::MediaType media_type,
                               const RtpTransceiverInit& init) { … }

RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
PeerConnection::AddTransceiver(
    cricket::MediaType media_type,
    rtc::scoped_refptr<MediaStreamTrackInterface> track,
    const RtpTransceiverInit& init,
    bool update_negotiation_needed) { … }

void PeerConnection::OnNegotiationNeeded() { … }

rtc::scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender(
    const std::string& kind,
    const std::string& stream_id) { … }

std::vector<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::GetSenders()
    const { … }

std::vector<rtc::scoped_refptr<RtpReceiverInterface>>
PeerConnection::GetReceivers() const { … }

std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>
PeerConnection::GetTransceivers() const { … }

bool PeerConnection::GetStats(StatsObserver* observer,
                              MediaStreamTrackInterface* track,
                              StatsOutputLevel level) { … }

void PeerConnection::GetStats(RTCStatsCollectorCallback* callback) { … }

void PeerConnection::GetStats(
    rtc::scoped_refptr<RtpSenderInterface> selector,
    rtc::scoped_refptr<RTCStatsCollectorCallback> callback) { … }

void PeerConnection::GetStats(
    rtc::scoped_refptr<RtpReceiverInterface> selector,
    rtc::scoped_refptr<RTCStatsCollectorCallback> callback) { … }

PeerConnectionInterface::SignalingState PeerConnection::signaling_state() { … }

PeerConnectionInterface::IceConnectionState
PeerConnection::ice_connection_state() { … }

PeerConnectionInterface::IceConnectionState
PeerConnection::standardized_ice_connection_state() { … }

PeerConnectionInterface::PeerConnectionState
PeerConnection::peer_connection_state() { … }

PeerConnectionInterface::IceGatheringState
PeerConnection::ice_gathering_state() { … }

absl::optional<bool> PeerConnection::can_trickle_ice_candidates() { … }

RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>>
PeerConnection::CreateDataChannelOrError(const std::string& label,
                                         const DataChannelInit* config) { … }

void PeerConnection::RestartIce() { … }

void PeerConnection::CreateOffer(CreateSessionDescriptionObserver* observer,
                                 const RTCOfferAnswerOptions& options) { … }

void PeerConnection::CreateAnswer(CreateSessionDescriptionObserver* observer,
                                  const RTCOfferAnswerOptions& options) { … }

void PeerConnection::SetLocalDescription(
    SetSessionDescriptionObserver* observer,
    SessionDescriptionInterface* desc_ptr) { … }

void PeerConnection::SetLocalDescription(
    std::unique_ptr<SessionDescriptionInterface> desc,
    rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer) { … }

void PeerConnection::SetLocalDescription(
    SetSessionDescriptionObserver* observer) { … }

void PeerConnection::SetLocalDescription(
    rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer) { … }

void PeerConnection::SetRemoteDescription(
    SetSessionDescriptionObserver* observer,
    SessionDescriptionInterface* desc_ptr) { … }

void PeerConnection::SetRemoteDescription(
    std::unique_ptr<SessionDescriptionInterface> desc,
    rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer) { … }

PeerConnectionInterface::RTCConfiguration PeerConnection::GetConfiguration() { … }

RTCError PeerConnection::SetConfiguration(
    const RTCConfiguration& configuration) { … }

bool PeerConnection::AddIceCandidate(
    const IceCandidateInterface* ice_candidate) { … }

void PeerConnection::AddIceCandidate(
    std::unique_ptr<IceCandidateInterface> candidate,
    std::function<void(RTCError)> callback) { … }

bool PeerConnection::RemoveIceCandidates(
    const std::vector<cricket::Candidate>& candidates) { … }

RTCError PeerConnection::SetBitrate(const BitrateSettings& bitrate) { … }

void PeerConnection::ReconfigureBandwidthEstimation(
    const BandwidthEstimationSettings& settings) { … }

void PeerConnection::SetAudioPlayout(bool playout) { … }

void PeerConnection::SetAudioRecording(bool recording) { … }

void PeerConnection::AddAdaptationResource(
    rtc::scoped_refptr<Resource> resource) { … }

bool PeerConnection::ConfiguredForMedia() const { … }

bool PeerConnection::StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output,
                                      int64_t output_period_ms) { … }

bool PeerConnection::StartRtcEventLog(
    std::unique_ptr<RtcEventLogOutput> output) { … }

void PeerConnection::StopRtcEventLog() { … }

rtc::scoped_refptr<DtlsTransportInterface>
PeerConnection::LookupDtlsTransportByMid(const std::string& mid) { … }

rtc::scoped_refptr<DtlsTransport>
PeerConnection::LookupDtlsTransportByMidInternal(const std::string& mid) { … }

rtc::scoped_refptr<SctpTransportInterface> PeerConnection::GetSctpTransport()
    const { … }

const SessionDescriptionInterface* PeerConnection::local_description() const { … }

const SessionDescriptionInterface* PeerConnection::remote_description() const { … }

const SessionDescriptionInterface* PeerConnection::current_local_description()
    const { … }

const SessionDescriptionInterface* PeerConnection::current_remote_description()
    const { … }

const SessionDescriptionInterface* PeerConnection::pending_local_description()
    const { … }

const SessionDescriptionInterface* PeerConnection::pending_remote_description()
    const { … }

void PeerConnection::Close() { … }

void PeerConnection::SetIceConnectionState(IceConnectionState new_state) { … }

void PeerConnection::SetStandardizedIceConnectionState(
    PeerConnectionInterface::IceConnectionState new_state) { … }

void PeerConnection::SetConnectionState(
    PeerConnectionInterface::PeerConnectionState new_state) { … }

void PeerConnection::ReportFirstConnectUsageMetrics() { … }

void PeerConnection::OnIceGatheringChange(
    PeerConnectionInterface::IceGatheringState new_state) { … }

void PeerConnection::OnIceCandidate(
    std::unique_ptr<IceCandidateInterface> candidate) { … }

void PeerConnection::OnIceCandidateError(const std::string& address,
                                         int port,
                                         const std::string& url,
                                         int error_code,
                                         const std::string& error_text) { … }

void PeerConnection::OnIceCandidatesRemoved(
    const std::vector<cricket::Candidate>& candidates) { … }

void PeerConnection::OnSelectedCandidatePairChanged(
    const cricket::CandidatePairChangeEvent& event) { … }

bool PeerConnection::CreateDataChannelTransport(absl::string_view mid) { … }

void PeerConnection::DestroyDataChannelTransport(RTCError error) { … }

void PeerConnection::OnSctpDataChannelStateChanged(
    int channel_id,
    DataChannelInterface::DataState state) { … }

PeerConnection::InitializePortAllocatorResult
PeerConnection::InitializePortAllocator_n(
    const cricket::ServerAddresses& stun_servers,
    const std::vector<cricket::RelayServerConfig>& turn_servers,
    const RTCConfiguration& configuration) { … }

bool PeerConnection::ReconfigurePortAllocator_n(
    const cricket::ServerAddresses& stun_servers,
    const std::vector<cricket::RelayServerConfig>& turn_servers,
    IceTransportsType type,
    int candidate_pool_size,
    PortPrunePolicy turn_port_prune_policy,
    TurnCustomizer* turn_customizer,
    absl::optional<int> stun_candidate_keepalive_interval,
    bool have_local_description) { … }

bool PeerConnection::StartRtcEventLog_w(
    std::unique_ptr<RtcEventLogOutput> output,
    int64_t output_period_ms) { … }

void PeerConnection::StopRtcEventLog_w() { … }

absl::optional<rtc::SSLRole> PeerConnection::GetSctpSslRole_n() { … }

bool PeerConnection::GetSslRole(const std::string& content_name,
                                rtc::SSLRole* role) { … }

bool PeerConnection::GetTransportDescription(
    const SessionDescription* description,
    const std::string& content_name,
    cricket::TransportDescription* tdesc) { … }

std::vector<DataChannelStats> PeerConnection::GetDataChannelStats() const { … }

absl::optional<std::string> PeerConnection::sctp_transport_name() const { … }

void PeerConnection::SetSctpTransportName(std::string sctp_transport_name) { … }

absl::optional<std::string> PeerConnection::sctp_mid() const { … }

cricket::CandidateStatsList PeerConnection::GetPooledCandidateStats() const { … }

std::map<std::string, cricket::TransportStats>
PeerConnection::GetTransportStatsByNames(
    const std::set<std::string>& transport_names) { … }

bool PeerConnection::GetLocalCertificate(
    const std::string& transport_name,
    rtc::scoped_refptr<rtc::RTCCertificate>* certificate) { … }

std::unique_ptr<rtc::SSLCertChain> PeerConnection::GetRemoteSSLCertChain(
    const std::string& transport_name) { … }

bool PeerConnection::IceRestartPending(const std::string& content_name) const { … }

bool PeerConnection::NeedsIceRestart(const std::string& content_name) const { … }

void PeerConnection::OnTransportControllerConnectionState(
    cricket::IceConnectionState state) { … }

void PeerConnection::OnTransportControllerCandidatesGathered(
    const std::string& transport_name,
    const cricket::Candidates& candidates) { … }

void PeerConnection::OnTransportControllerCandidateError(
    const cricket::IceCandidateErrorEvent& event) { … }

void PeerConnection::OnTransportControllerCandidatesRemoved(
    const std::vector<cricket::Candidate>& candidates) { … }

void PeerConnection::OnTransportControllerCandidateChanged(
    const cricket::CandidatePairChangeEvent& event) { … }

void PeerConnection::OnTransportControllerDtlsHandshakeError(
    rtc::SSLHandshakeError error) { … }

// Returns the media index for a local ice candidate given the content name.
bool PeerConnection::GetLocalCandidateMediaIndex(
    const std::string& content_name,
    int* sdp_mline_index) { … }

Call::Stats PeerConnection::GetCallStats() { … }

absl::optional<AudioDeviceModule::Stats> PeerConnection::GetAudioDeviceStats() { … }

absl::optional<std::string> PeerConnection::SetupDataChannelTransport_n(
    absl::string_view mid) { … }

void PeerConnection::TeardownDataChannelTransport_n(RTCError error) { … }

// Returns false if bundle is enabled and rtcp_mux is disabled.
bool PeerConnection::ValidateBundleSettings(
    const SessionDescription* desc,
    const std::map<std::string, const cricket::ContentGroup*>&
        bundle_groups_by_mid) { … }

void PeerConnection::ReportSdpBundleUsage(
    const SessionDescriptionInterface& remote_description) { … }

void PeerConnection::ReportIceCandidateCollected(
    const cricket::Candidate& candidate) { … }

void PeerConnection::NoteUsageEvent(UsageEvent event) { … }

// Asynchronously adds remote candidates on the network thread.
void PeerConnection::AddRemoteCandidate(const std::string& mid,
                                        const cricket::Candidate& candidate) { … }

void PeerConnection::ReportUsagePattern() const { … }

void PeerConnection::ReportRemoteIceCandidateAdded(
    const cricket::Candidate& candidate) { … }

bool PeerConnection::SrtpRequired() const { … }

void PeerConnection::OnTransportControllerGatheringState(
    cricket::IceGatheringState state) { … }

// Runs on network_thread().
void PeerConnection::ReportTransportStats(
    std::vector<RtpTransceiverProxyRefPtr> transceivers) { … }

// Walk through the ConnectionInfos to gather best connection usage
// for IPv4 and IPv6.
// static (no member state required)
void PeerConnection::ReportBestConnectionState(
    const cricket::TransportStats& stats) { … }

// static
void PeerConnection::ReportNegotiatedCiphers(
    bool dtls_enabled,
    const cricket::TransportStats& stats,
    const std::set<cricket::MediaType>& media_types) { … }

bool PeerConnection::OnTransportChanged(
    const std::string& mid,
    RtpTransportInternal* rtp_transport,
    rtc::scoped_refptr<DtlsTransport> dtls_transport,
    DataChannelTransportInterface* data_channel_transport) { … }

PeerConnectionObserver* PeerConnection::Observer() const { … }

void PeerConnection::StartSctpTransport(int local_port,
                                        int remote_port,
                                        int max_message_size) { … }

CryptoOptions PeerConnection::GetCryptoOptions() { … }

void PeerConnection::ClearStatsCache() { … }

bool PeerConnection::ShouldFireNegotiationNeededEvent(uint32_t event_id) { … }

void PeerConnection::RequestUsagePatternReportForTesting() { … }

std::function<void(const rtc::CopyOnWriteBuffer& packet,
                   int64_t packet_time_us)>
PeerConnection::InitializeRtcpCallback() { … }

std::function<void(const RtpPacketReceived& parsed_packet)>
PeerConnection::InitializeUnDemuxablePacketHandler() { … }

}  // namespace webrtc