| /* | |
| * 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/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/helpers.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" | |
| using cricket::ContentInfo; | |
| using cricket::ContentInfos; | |
| using cricket::MediaContentDescription; | |
| using cricket::MediaProtocolType; | |
| using cricket::RidDescription; | |
| using cricket::RidDirection; | |
| using cricket::SessionDescription; | |
| using cricket::SimulcastDescription; | |
| using cricket::SimulcastLayer; | |
| using cricket::SimulcastLayerList; | |
| using cricket::StreamParams; | |
| using cricket::TransportInfo; | |
| using cricket::LOCAL_PORT_TYPE; | |
| using cricket::PRFLX_PORT_TYPE; | |
| using cricket::RELAY_PORT_TYPE; | |
| using cricket::STUN_PORT_TYPE; | |
| namespace webrtc { | |
| namespace { | |
| // UMA metric names. | |
| const char kSimulcastNumberOfEncodings[] = | |
| "WebRTC.PeerConnection.Simulcast.NumberOfSendEncodings"; | |
| static const int REPORT_USAGE_PATTERN_DELAY_MS = 60000; | |
| uint32_t ConvertIceTransportTypeToCandidateFilter( | |
| PeerConnectionInterface::IceTransportsType type) { | |
| switch (type) { | |
| case PeerConnectionInterface::kNone: | |
| return cricket::CF_NONE; | |
| case PeerConnectionInterface::kRelay: | |
| return cricket::CF_RELAY; | |
| case PeerConnectionInterface::kNoHost: | |
| return (cricket::CF_ALL & ~cricket::CF_HOST); | |
| case PeerConnectionInterface::kAll: | |
| return cricket::CF_ALL; | |
| default: | |
| RTC_DCHECK_NOTREACHED(); | |
| } | |
| return cricket::CF_NONE; | |
| } | |
| IceCandidatePairType GetIceCandidatePairCounter( | |
| const cricket::Candidate& local, | |
| const cricket::Candidate& remote) { | |
| const auto& l = local.type(); | |
| const auto& r = remote.type(); | |
| const auto& host = LOCAL_PORT_TYPE; | |
| const auto& srflx = STUN_PORT_TYPE; | |
| const auto& relay = RELAY_PORT_TYPE; | |
| const auto& prflx = PRFLX_PORT_TYPE; | |
| if (l == host && r == host) { | |
| bool local_hostname = | |
| !local.address().hostname().empty() && local.address().IsUnresolvedIP(); | |
| bool remote_hostname = !remote.address().hostname().empty() && | |
| remote.address().IsUnresolvedIP(); | |
| bool local_private = IPIsPrivate(local.address().ipaddr()); | |
| bool remote_private = IPIsPrivate(remote.address().ipaddr()); | |
| if (local_hostname) { | |
| if (remote_hostname) { | |
| return kIceCandidatePairHostNameHostName; | |
| } else if (remote_private) { | |
| return kIceCandidatePairHostNameHostPrivate; | |
| } else { | |
| return kIceCandidatePairHostNameHostPublic; | |
| } | |
| } else if (local_private) { | |
| if (remote_hostname) { | |
| return kIceCandidatePairHostPrivateHostName; | |
| } else if (remote_private) { | |
| return kIceCandidatePairHostPrivateHostPrivate; | |
| } else { | |
| return kIceCandidatePairHostPrivateHostPublic; | |
| } | |
| } else { | |
| if (remote_hostname) { | |
| return kIceCandidatePairHostPublicHostName; | |
| } else if (remote_private) { | |
| return kIceCandidatePairHostPublicHostPrivate; | |
| } else { | |
| return kIceCandidatePairHostPublicHostPublic; | |
| } | |
| } | |
| } | |
| if (l == host && r == srflx) | |
| return kIceCandidatePairHostSrflx; | |
| if (l == host && r == relay) | |
| return kIceCandidatePairHostRelay; | |
| if (l == host && r == prflx) | |
| return kIceCandidatePairHostPrflx; | |
| if (l == srflx && r == host) | |
| return kIceCandidatePairSrflxHost; | |
| if (l == srflx && r == srflx) | |
| return kIceCandidatePairSrflxSrflx; | |
| if (l == srflx && r == relay) | |
| return kIceCandidatePairSrflxRelay; | |
| if (l == srflx && r == prflx) | |
| return kIceCandidatePairSrflxPrflx; | |
| if (l == relay && r == host) | |
| return kIceCandidatePairRelayHost; | |
| if (l == relay && r == srflx) | |
| return kIceCandidatePairRelaySrflx; | |
| if (l == relay && r == relay) | |
| return kIceCandidatePairRelayRelay; | |
| if (l == relay && r == prflx) | |
| return kIceCandidatePairRelayPrflx; | |
| if (l == prflx && r == host) | |
| return kIceCandidatePairPrflxHost; | |
| if (l == prflx && r == srflx) | |
| return kIceCandidatePairPrflxSrflx; | |
| if (l == prflx && r == relay) | |
| return kIceCandidatePairPrflxRelay; | |
| return kIceCandidatePairMax; | |
| } | |
| absl::optional<int> RTCConfigurationToIceConfigOptionalInt( | |
| int rtc_configuration_parameter) { | |
| if (rtc_configuration_parameter == | |
| PeerConnectionInterface::RTCConfiguration::kUndefined) { | |
| return absl::nullopt; | |
| } | |
| return 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) { | |
| if (current == modified) { | |
| return false; | |
| } | |
| if (!surface_ice_candidates_on_ice_transport_type_changed) { | |
| return true; | |
| } | |
| auto current_filter = ConvertIceTransportTypeToCandidateFilter(current); | |
| auto modified_filter = ConvertIceTransportTypeToCandidateFilter(modified); | |
| // If surface_ice_candidates_on_ice_transport_type_changed is true and we | |
| // extend the filter, then no ice restart is needed. | |
| return (current_filter & modified_filter) != current_filter; | |
| } | |
| cricket::IceConfig ParseIceConfig( | |
| const PeerConnectionInterface::RTCConfiguration& config) { | |
| cricket::ContinualGatheringPolicy gathering_policy; | |
| switch (config.continual_gathering_policy) { | |
| case PeerConnectionInterface::GATHER_ONCE: | |
| gathering_policy = cricket::GATHER_ONCE; | |
| break; | |
| case PeerConnectionInterface::GATHER_CONTINUALLY: | |
| gathering_policy = cricket::GATHER_CONTINUALLY; | |
| break; | |
| default: | |
| RTC_DCHECK_NOTREACHED(); | |
| gathering_policy = cricket::GATHER_ONCE; | |
| } | |
| cricket::IceConfig ice_config; | |
| ice_config.receiving_timeout = RTCConfigurationToIceConfigOptionalInt( | |
| config.ice_connection_receiving_timeout); | |
| ice_config.prioritize_most_likely_candidate_pairs = | |
| config.prioritize_most_likely_ice_candidate_pairs; | |
| ice_config.backup_connection_ping_interval = | |
| RTCConfigurationToIceConfigOptionalInt( | |
| config.ice_backup_candidate_pair_ping_interval); | |
| ice_config.continual_gathering_policy = gathering_policy; | |
| ice_config.presume_writable_when_fully_relayed = | |
| config.presume_writable_when_fully_relayed; | |
| ice_config.surface_ice_candidates_on_ice_transport_type_changed = | |
| config.surface_ice_candidates_on_ice_transport_type_changed; | |
| ice_config.ice_check_interval_strong_connectivity = | |
| config.ice_check_interval_strong_connectivity; | |
| ice_config.ice_check_interval_weak_connectivity = | |
| config.ice_check_interval_weak_connectivity; | |
| ice_config.ice_check_min_interval = config.ice_check_min_interval; | |
| ice_config.ice_unwritable_timeout = config.ice_unwritable_timeout; | |
| ice_config.ice_unwritable_min_checks = config.ice_unwritable_min_checks; | |
| ice_config.ice_inactive_timeout = config.ice_inactive_timeout; | |
| ice_config.stun_keepalive_interval = config.stun_candidate_keepalive_interval; | |
| ice_config.network_preference = config.network_preference; | |
| ice_config.stable_writable_connection_ping_interval = | |
| config.stable_writable_connection_ping_interval_ms; | |
| return ice_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) { | |
| return cricket::P2PTransportChannel::ValidateIceConfig( | |
| ParseIceConfig(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) { | |
| // Note that this isn't possible through chromium, since it's an unsigned | |
| // short in WebIDL. | |
| if (ice_candidate_pool_size < 0 || | |
| ice_candidate_pool_size > static_cast<int>(UINT16_MAX)) { | |
| return RTCError(RTCErrorType::INVALID_RANGE); | |
| } | |
| // According to JSEP, after setLocalDescription, changing the candidate pool | |
| // size is not allowed, and changing the set of ICE servers will not result | |
| // in new candidates being gathered. | |
| if (previous_ice_candidate_pool_size.has_value() && | |
| ice_candidate_pool_size != previous_ice_candidate_pool_size.value()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_MODIFICATION, | |
| "Can't change candidate pool size after calling " | |
| "SetLocalDescription."); | |
| } | |
| return RTCError::OK(); | |
| } | |
| // 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) { | |
| PeerConnectionInterface::RTCConfiguration modified_config = | |
| existing_configuration; | |
| modified_config.servers = configuration.servers; | |
| modified_config.type = configuration.type; | |
| modified_config.ice_candidate_pool_size = | |
| configuration.ice_candidate_pool_size; | |
| modified_config.prune_turn_ports = configuration.prune_turn_ports; | |
| modified_config.turn_port_prune_policy = configuration.turn_port_prune_policy; | |
| modified_config.surface_ice_candidates_on_ice_transport_type_changed = | |
| configuration.surface_ice_candidates_on_ice_transport_type_changed; | |
| modified_config.ice_check_min_interval = configuration.ice_check_min_interval; | |
| modified_config.ice_check_interval_strong_connectivity = | |
| configuration.ice_check_interval_strong_connectivity; | |
| modified_config.ice_check_interval_weak_connectivity = | |
| configuration.ice_check_interval_weak_connectivity; | |
| modified_config.ice_unwritable_timeout = configuration.ice_unwritable_timeout; | |
| modified_config.ice_unwritable_min_checks = | |
| configuration.ice_unwritable_min_checks; | |
| modified_config.ice_inactive_timeout = configuration.ice_inactive_timeout; | |
| modified_config.stun_candidate_keepalive_interval = | |
| configuration.stun_candidate_keepalive_interval; | |
| modified_config.turn_customizer = configuration.turn_customizer; | |
| modified_config.network_preference = configuration.network_preference; | |
| modified_config.active_reset_srtp_params = | |
| configuration.active_reset_srtp_params; | |
| modified_config.turn_logging_id = configuration.turn_logging_id; | |
| modified_config.allow_codec_switching = configuration.allow_codec_switching; | |
| modified_config.stable_writable_connection_ping_interval_ms = | |
| configuration.stable_writable_connection_ping_interval_ms; | |
| if (configuration != modified_config) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_MODIFICATION, | |
| "Modifying the configuration in an unsupported way."); | |
| } | |
| RTCError err = ValidateConfiguration(modified_config); | |
| if (!err.ok()) { | |
| return err; | |
| } | |
| return modified_config; | |
| } | |
| bool HasRtcpMuxEnabled(const cricket::ContentInfo* content) { | |
| return content->media_description()->rtcp_mux(); | |
| } | |
| bool DtlsEnabled(const PeerConnectionInterface::RTCConfiguration& configuration, | |
| const PeerConnectionFactoryInterface::Options& options, | |
| const PeerConnectionDependencies& dependencies) { | |
| if (options.disable_encryption) | |
| return false; | |
| // Enable DTLS by default if we have an identity store or a certificate. | |
| bool default_enabled = | |
| (dependencies.cert_generator || !configuration.certificates.empty()); | |
| #if defined(WEBRTC_FUCHSIA) | |
| // The `configuration` can override the default value. | |
| return configuration.enable_dtls_srtp.value_or(default_enabled); | |
| #else | |
| return default_enabled; | |
| #endif | |
| } | |
| // 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) { | |
| RTC_DCHECK(stun_servers.empty()); | |
| RTC_DCHECK(turn_servers.empty()); | |
| RTCError err = ParseIceServersOrError(configuration.servers, &stun_servers, | |
| &turn_servers); | |
| if (!err.ok()) { | |
| return err; | |
| } | |
| // Restrict number of TURN servers. | |
| if (turn_servers.size() > cricket::kMaxTurnServers) { | |
| RTC_LOG(LS_WARNING) << "Number of configured TURN servers is " | |
| << turn_servers.size() | |
| << " which exceeds the maximum allowed number of " | |
| << cricket::kMaxTurnServers; | |
| turn_servers.resize(cricket::kMaxTurnServers); | |
| } | |
| // Add the turn logging id to all turn servers | |
| for (cricket::RelayServerConfig& turn_server : turn_servers) { | |
| turn_server.turn_logging_id = configuration.turn_logging_id; | |
| } | |
| // Note if STUN or TURN servers were supplied. | |
| if (!stun_servers.empty()) { | |
| usage_pattern.NoteUsageEvent(UsageEvent::STUN_SERVER_ADDED); | |
| } | |
| if (!turn_servers.empty()) { | |
| usage_pattern.NoteUsageEvent(UsageEvent::TURN_SERVER_ADDED); | |
| } | |
| return RTCError::OK(); | |
| } | |
| } // namespace | |
| bool PeerConnectionInterface::RTCConfiguration::operator==( | |
| const PeerConnectionInterface::RTCConfiguration& o) const { | |
| // This static_assert prevents us from accidentally breaking operator==. | |
| // Note: Order matters! Fields must be ordered the same as RTCConfiguration. | |
| struct stuff_being_tested_for_equality { | |
| IceServers servers; | |
| IceTransportsType type; | |
| BundlePolicy bundle_policy; | |
| RtcpMuxPolicy rtcp_mux_policy; | |
| std::vector<rtc::scoped_refptr<rtc::RTCCertificate>> certificates; | |
| int ice_candidate_pool_size; | |
| bool disable_ipv6_on_wifi; | |
| int max_ipv6_networks; | |
| bool disable_link_local_networks; | |
| absl::optional<int> screencast_min_bitrate; | |
| #if defined(WEBRTC_FUCHSIA) | |
| absl::optional<bool> enable_dtls_srtp; | |
| #endif | |
| TcpCandidatePolicy tcp_candidate_policy; | |
| CandidateNetworkPolicy candidate_network_policy; | |
| int audio_jitter_buffer_max_packets; | |
| bool audio_jitter_buffer_fast_accelerate; | |
| int audio_jitter_buffer_min_delay_ms; | |
| int ice_connection_receiving_timeout; | |
| int ice_backup_candidate_pair_ping_interval; | |
| ContinualGatheringPolicy continual_gathering_policy; | |
| bool prioritize_most_likely_ice_candidate_pairs; | |
| struct cricket::MediaConfig media_config; | |
| bool prune_turn_ports; | |
| PortPrunePolicy turn_port_prune_policy; | |
| bool presume_writable_when_fully_relayed; | |
| bool enable_ice_renomination; | |
| bool redetermine_role_on_ice_restart; | |
| bool surface_ice_candidates_on_ice_transport_type_changed; | |
| absl::optional<int> ice_check_interval_strong_connectivity; | |
| absl::optional<int> ice_check_interval_weak_connectivity; | |
| absl::optional<int> ice_check_min_interval; | |
| absl::optional<int> ice_unwritable_timeout; | |
| absl::optional<int> ice_unwritable_min_checks; | |
| absl::optional<int> ice_inactive_timeout; | |
| absl::optional<int> stun_candidate_keepalive_interval; | |
| TurnCustomizer* turn_customizer; | |
| SdpSemantics sdp_semantics; | |
| absl::optional<rtc::AdapterType> network_preference; | |
| bool active_reset_srtp_params; | |
| absl::optional<CryptoOptions> crypto_options; | |
| bool offer_extmap_allow_mixed; | |
| std::string turn_logging_id; | |
| bool enable_implicit_rollback; | |
| absl::optional<bool> allow_codec_switching; | |
| absl::optional<int> report_usage_pattern_delay_ms; | |
| absl::optional<int> stable_writable_connection_ping_interval_ms; | |
| VpnPreference vpn_preference; | |
| std::vector<rtc::NetworkMask> vpn_list; | |
| PortAllocatorConfig port_allocator_config; | |
| absl::optional<TimeDelta> pacer_burst_interval; | |
| }; | |
| static_assert(sizeof(stuff_being_tested_for_equality) == sizeof(*this), | |
| "Did you add something to RTCConfiguration and forget to " | |
| "update operator==?"); | |
| return type == o.type && servers == o.servers && | |
| bundle_policy == o.bundle_policy && | |
| rtcp_mux_policy == o.rtcp_mux_policy && | |
| tcp_candidate_policy == o.tcp_candidate_policy && | |
| candidate_network_policy == o.candidate_network_policy && | |
| audio_jitter_buffer_max_packets == o.audio_jitter_buffer_max_packets && | |
| audio_jitter_buffer_fast_accelerate == | |
| o.audio_jitter_buffer_fast_accelerate && | |
| audio_jitter_buffer_min_delay_ms == | |
| o.audio_jitter_buffer_min_delay_ms && | |
| ice_connection_receiving_timeout == | |
| o.ice_connection_receiving_timeout && | |
| ice_backup_candidate_pair_ping_interval == | |
| o.ice_backup_candidate_pair_ping_interval && | |
| continual_gathering_policy == o.continual_gathering_policy && | |
| certificates == o.certificates && | |
| prioritize_most_likely_ice_candidate_pairs == | |
| o.prioritize_most_likely_ice_candidate_pairs && | |
| media_config == o.media_config && | |
| disable_ipv6_on_wifi == o.disable_ipv6_on_wifi && | |
| max_ipv6_networks == o.max_ipv6_networks && | |
| disable_link_local_networks == o.disable_link_local_networks && | |
| screencast_min_bitrate == o.screencast_min_bitrate && | |
| #if defined(WEBRTC_FUCHSIA) | |
| enable_dtls_srtp == o.enable_dtls_srtp && | |
| #endif | |
| ice_candidate_pool_size == o.ice_candidate_pool_size && | |
| prune_turn_ports == o.prune_turn_ports && | |
| turn_port_prune_policy == o.turn_port_prune_policy && | |
| presume_writable_when_fully_relayed == | |
| o.presume_writable_when_fully_relayed && | |
| enable_ice_renomination == o.enable_ice_renomination && | |
| redetermine_role_on_ice_restart == o.redetermine_role_on_ice_restart && | |
| surface_ice_candidates_on_ice_transport_type_changed == | |
| o.surface_ice_candidates_on_ice_transport_type_changed && | |
| ice_check_interval_strong_connectivity == | |
| o.ice_check_interval_strong_connectivity && | |
| ice_check_interval_weak_connectivity == | |
| o.ice_check_interval_weak_connectivity && | |
| ice_check_min_interval == o.ice_check_min_interval && | |
| ice_unwritable_timeout == o.ice_unwritable_timeout && | |
| ice_unwritable_min_checks == o.ice_unwritable_min_checks && | |
| ice_inactive_timeout == o.ice_inactive_timeout && | |
| stun_candidate_keepalive_interval == | |
| o.stun_candidate_keepalive_interval && | |
| turn_customizer == o.turn_customizer && | |
| sdp_semantics == o.sdp_semantics && | |
| network_preference == o.network_preference && | |
| active_reset_srtp_params == o.active_reset_srtp_params && | |
| crypto_options == o.crypto_options && | |
| offer_extmap_allow_mixed == o.offer_extmap_allow_mixed && | |
| turn_logging_id == o.turn_logging_id && | |
| enable_implicit_rollback == o.enable_implicit_rollback && | |
| allow_codec_switching == o.allow_codec_switching && | |
| report_usage_pattern_delay_ms == o.report_usage_pattern_delay_ms && | |
| stable_writable_connection_ping_interval_ms == | |
| o.stable_writable_connection_ping_interval_ms && | |
| vpn_preference == o.vpn_preference && vpn_list == o.vpn_list && | |
| port_allocator_config.min_port == o.port_allocator_config.min_port && | |
| port_allocator_config.max_port == o.port_allocator_config.max_port && | |
| port_allocator_config.flags == o.port_allocator_config.flags && | |
| pacer_burst_interval == o.pacer_burst_interval; | |
| } | |
| bool PeerConnectionInterface::RTCConfiguration::operator!=( | |
| const PeerConnectionInterface::RTCConfiguration& o) const { | |
| return !(*this == o); | |
| } | |
| RTCErrorOr<rtc::scoped_refptr<PeerConnection>> PeerConnection::Create( | |
| rtc::scoped_refptr<ConnectionContext> context, | |
| const PeerConnectionFactoryInterface::Options& options, | |
| std::unique_ptr<RtcEventLog> event_log, | |
| std::unique_ptr<Call> call, | |
| const PeerConnectionInterface::RTCConfiguration& configuration, | |
| PeerConnectionDependencies dependencies) { | |
| // TODO(https://crbug.com/webrtc/13528): Remove support for kPlanB. | |
| if (configuration.sdp_semantics == SdpSemantics::kPlanB_DEPRECATED) { | |
| RTC_LOG(LS_WARNING) | |
| << "PeerConnection constructed with legacy SDP semantics!"; | |
| } | |
| RTCError config_error = cricket::P2PTransportChannel::ValidateIceConfig( | |
| ParseIceConfig(configuration)); | |
| if (!config_error.ok()) { | |
| RTC_LOG(LS_ERROR) << "Invalid ICE configuration: " | |
| << config_error.message(); | |
| return config_error; | |
| } | |
| if (!dependencies.allocator) { | |
| RTC_LOG(LS_ERROR) | |
| << "PeerConnection initialized without a PortAllocator? " | |
| "This shouldn't happen if using PeerConnectionFactory."; | |
| return RTCError( | |
| RTCErrorType::INVALID_PARAMETER, | |
| "Attempt to create a PeerConnection without a PortAllocatorFactory"); | |
| } | |
| if (!dependencies.observer) { | |
| // TODO(deadbeef): Why do we do this? | |
| RTC_LOG(LS_ERROR) << "PeerConnection initialized without a " | |
| "PeerConnectionObserver"; | |
| return RTCError(RTCErrorType::INVALID_PARAMETER, | |
| "Attempt to create a PeerConnection without an observer"); | |
| } | |
| bool is_unified_plan = | |
| configuration.sdp_semantics == SdpSemantics::kUnifiedPlan; | |
| bool dtls_enabled = DtlsEnabled(configuration, options, dependencies); | |
| // Interim code: If an AsyncResolverFactory is given, but not an | |
| // AsyncDnsResolverFactory, wrap it in a WrappingAsyncDnsResolverFactory | |
| // If neither is given, create a BasicAsyncDnsResolverFactory. | |
| // TODO(bugs.webrtc.org/12598): Remove code once all callers pass a | |
| // AsyncDnsResolverFactory. | |
| #pragma clang diagnostic push | |
| #pragma clang diagnostic ignored "-Wdeprecated-declarations" | |
| if (dependencies.async_dns_resolver_factory && | |
| dependencies.async_resolver_factory) { | |
| RTC_LOG(LS_ERROR) | |
| << "Attempt to set both old and new type of DNS resolver factory"; | |
| return RTCError(RTCErrorType::INVALID_PARAMETER, | |
| "Both old and new type of DNS resolver given"); | |
| } | |
| if (!dependencies.async_dns_resolver_factory) { | |
| if (dependencies.async_resolver_factory) { | |
| dependencies.async_dns_resolver_factory = | |
| std::make_unique<WrappingAsyncDnsResolverFactory>( | |
| std::move(dependencies.async_resolver_factory)); | |
| } else { | |
| dependencies.async_dns_resolver_factory = | |
| std::make_unique<BasicAsyncDnsResolverFactory>(); | |
| } | |
| } | |
| #pragma clang diagnostic pop | |
| // The PeerConnection constructor consumes some, but not all, dependencies. | |
| auto pc = rtc::make_ref_counted<PeerConnection>( | |
| context, options, is_unified_plan, std::move(event_log), std::move(call), | |
| dependencies, dtls_enabled); | |
| RTCError init_error = pc->Initialize(configuration, std::move(dependencies)); | |
| if (!init_error.ok()) { | |
| RTC_LOG(LS_ERROR) << "PeerConnection initialization failed"; | |
| return init_error; | |
| } | |
| return pc; | |
| } | |
| PeerConnection::PeerConnection( | |
| rtc::scoped_refptr<ConnectionContext> context, | |
| const PeerConnectionFactoryInterface::Options& options, | |
| bool is_unified_plan, | |
| std::unique_ptr<RtcEventLog> event_log, | |
| std::unique_ptr<Call> call, | |
| PeerConnectionDependencies& dependencies, | |
| bool dtls_enabled) | |
| : context_(context), | |
| trials_(std::move(dependencies.trials), &context->field_trials()), | |
| options_(options), | |
| observer_(dependencies.observer), | |
| is_unified_plan_(is_unified_plan), | |
| event_log_(std::move(event_log)), | |
| event_log_ptr_(event_log_.get()), | |
| async_dns_resolver_factory_( | |
| std::move(dependencies.async_dns_resolver_factory)), | |
| port_allocator_(std::move(dependencies.allocator)), | |
| ice_transport_factory_(std::move(dependencies.ice_transport_factory)), | |
| tls_cert_verifier_(std::move(dependencies.tls_cert_verifier)), | |
| call_(std::move(call)), | |
| worker_thread_safety_(PendingTaskSafetyFlag::CreateAttachedToTaskQueue( | |
| /*alive=*/call_ != nullptr, | |
| worker_thread())), | |
| call_ptr_(call_.get()), | |
| // RFC 3264: The numeric value of the session id and version in the | |
| // o line MUST be representable with a "64 bit signed integer". | |
| // Due to this constraint session id `session_id_` is max limited to | |
| // LLONG_MAX. | |
| session_id_(rtc::ToString(rtc::CreateRandomId64() & LLONG_MAX)), | |
| dtls_enabled_(dtls_enabled), | |
| data_channel_controller_(this), | |
| message_handler_(signaling_thread()), | |
| weak_factory_(this) {} | |
| PeerConnection::~PeerConnection() { | |
| TRACE_EVENT0("webrtc", "PeerConnection::~PeerConnection"); | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (sdp_handler_) { | |
| sdp_handler_->PrepareForShutdown(); | |
| } | |
| // In case `Close()` wasn't called, always make sure the controller cancels | |
| // potentially pending operations. | |
| data_channel_controller_.PrepareForShutdown(); | |
| // Need to stop transceivers before destroying the stats collector because | |
| // AudioRtpSender has a reference to the LegacyStatsCollector it will update | |
| // when stopping. | |
| if (rtp_manager()) { | |
| for (const auto& transceiver : rtp_manager()->transceivers()->List()) { | |
| transceiver->StopInternal(); | |
| } | |
| } | |
| legacy_stats_.reset(nullptr); | |
| if (stats_collector_) { | |
| stats_collector_->WaitForPendingRequest(); | |
| stats_collector_ = nullptr; | |
| } | |
| if (sdp_handler_) { | |
| // Don't destroy BaseChannels until after stats has been cleaned up so that | |
| // the last stats request can still read from the channels. | |
| sdp_handler_->DestroyMediaChannels(); | |
| RTC_LOG(LS_INFO) << "Session: " << session_id() << " is destroyed."; | |
| sdp_handler_->ResetSessionDescFactory(); | |
| } | |
| // port_allocator_ and transport_controller_ live on the network thread and | |
| // should be destroyed there. | |
| transport_controller_copy_ = nullptr; | |
| network_thread()->BlockingCall([this] { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| TeardownDataChannelTransport_n(RTCError::OK()); | |
| transport_controller_.reset(); | |
| port_allocator_.reset(); | |
| if (network_thread_safety_) | |
| network_thread_safety_->SetNotAlive(); | |
| }); | |
| sctp_mid_s_.reset(); | |
| SetSctpTransportName(""); | |
| // call_ and event_log_ must be destroyed on the worker thread. | |
| worker_thread()->BlockingCall([this] { | |
| RTC_DCHECK_RUN_ON(worker_thread()); | |
| worker_thread_safety_->SetNotAlive(); | |
| call_.reset(); | |
| // The event log must outlive call (and any other object that uses it). | |
| event_log_.reset(); | |
| }); | |
| data_channel_controller_.PrepareForShutdown(); | |
| } | |
| RTCError PeerConnection::Initialize( | |
| const PeerConnectionInterface::RTCConfiguration& configuration, | |
| PeerConnectionDependencies dependencies) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| TRACE_EVENT0("webrtc", "PeerConnection::Initialize"); | |
| cricket::ServerAddresses stun_servers; | |
| std::vector<cricket::RelayServerConfig> turn_servers; | |
| RTCError parse_error = ParseAndValidateIceServersFromConfiguration( | |
| configuration, stun_servers, turn_servers, usage_pattern_); | |
| if (!parse_error.ok()) { | |
| return parse_error; | |
| } | |
| // Network thread initialization. | |
| transport_controller_copy_ = network_thread()->BlockingCall([&] { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| network_thread_safety_ = PendingTaskSafetyFlag::Create(); | |
| InitializePortAllocatorResult pa_result = | |
| InitializePortAllocator_n(stun_servers, turn_servers, configuration); | |
| // Send information about IPv4/IPv6 status. | |
| PeerConnectionAddressFamilyCounter address_family = | |
| pa_result.enable_ipv6 ? kPeerConnection_IPv6 : kPeerConnection_IPv4; | |
| RTC_HISTOGRAM_ENUMERATION("WebRTC.PeerConnection.IPMetrics", address_family, | |
| kPeerConnectionAddressFamilyCounter_Max); | |
| return InitializeTransportController_n(configuration, dependencies); | |
| }); | |
| configuration_ = configuration; | |
| legacy_stats_ = std::make_unique<LegacyStatsCollector>(this); | |
| stats_collector_ = RTCStatsCollector::Create(this); | |
| sdp_handler_ = SdpOfferAnswerHandler::Create(this, configuration, | |
| dependencies, context_.get()); | |
| rtp_manager_ = std::make_unique<RtpTransmissionManager>( | |
| IsUnifiedPlan(), context_.get(), &usage_pattern_, observer_, | |
| legacy_stats_.get(), [this]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->UpdateNegotiationNeeded(); | |
| }); | |
| // Add default audio/video transceivers for Plan B SDP. | |
| if (!IsUnifiedPlan()) { | |
| rtp_manager()->transceivers()->Add( | |
| RtpTransceiverProxyWithInternal<RtpTransceiver>::Create( | |
| signaling_thread(), rtc::make_ref_counted<RtpTransceiver>( | |
| cricket::MEDIA_TYPE_AUDIO, context()))); | |
| rtp_manager()->transceivers()->Add( | |
| RtpTransceiverProxyWithInternal<RtpTransceiver>::Create( | |
| signaling_thread(), rtc::make_ref_counted<RtpTransceiver>( | |
| cricket::MEDIA_TYPE_VIDEO, context()))); | |
| } | |
| int delay_ms = configuration.report_usage_pattern_delay_ms | |
| ? *configuration.report_usage_pattern_delay_ms | |
| : REPORT_USAGE_PATTERN_DELAY_MS; | |
| message_handler_.RequestUsagePatternReport( | |
| [this]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| ReportUsagePattern(); | |
| }, | |
| delay_ms); | |
| return RTCError::OK(); | |
| } | |
| JsepTransportController* PeerConnection::InitializeTransportController_n( | |
| const RTCConfiguration& configuration, | |
| const PeerConnectionDependencies& dependencies) { | |
| JsepTransportController::Config config; | |
| config.redetermine_role_on_ice_restart = | |
| configuration.redetermine_role_on_ice_restart; | |
| config.ssl_max_version = options_.ssl_max_version; | |
| config.disable_encryption = options_.disable_encryption; | |
| config.bundle_policy = configuration.bundle_policy; | |
| config.rtcp_mux_policy = configuration.rtcp_mux_policy; | |
| // TODO(bugs.webrtc.org/9891) - Remove options_.crypto_options then remove | |
| // this stub. | |
| config.crypto_options = configuration.crypto_options.has_value() | |
| ? *configuration.crypto_options | |
| : options_.crypto_options; | |
| config.transport_observer = this; | |
| config.rtcp_handler = InitializeRtcpCallback(); | |
| config.un_demuxable_packet_handler = InitializeUnDemuxablePacketHandler(); | |
| config.event_log = event_log_ptr_; | |
| #if defined(ENABLE_EXTERNAL_AUTH) | |
| config.enable_external_auth = true; | |
| #endif | |
| config.active_reset_srtp_params = configuration.active_reset_srtp_params; | |
| // DTLS has to be enabled to use SCTP. | |
| if (dtls_enabled_) { | |
| config.sctp_factory = context_->sctp_transport_factory(); | |
| } | |
| config.ice_transport_factory = ice_transport_factory_.get(); | |
| config.on_dtls_handshake_error_ = | |
| [weak_ptr = weak_factory_.GetWeakPtr()](rtc::SSLHandshakeError s) { | |
| if (weak_ptr) { | |
| weak_ptr->OnTransportControllerDtlsHandshakeError(s); | |
| } | |
| }; | |
| config.field_trials = trials_.get(); | |
| transport_controller_.reset(new JsepTransportController( | |
| network_thread(), port_allocator_.get(), | |
| async_dns_resolver_factory_.get(), std::move(config))); | |
| transport_controller_->SubscribeIceConnectionState( | |
| [this](cricket::IceConnectionState s) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| signaling_thread()->PostTask( | |
| SafeTask(signaling_thread_safety_.flag(), [this, s]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| OnTransportControllerConnectionState(s); | |
| })); | |
| }); | |
| transport_controller_->SubscribeConnectionState( | |
| [this](PeerConnectionInterface::PeerConnectionState s) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| signaling_thread()->PostTask( | |
| SafeTask(signaling_thread_safety_.flag(), [this, s]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| SetConnectionState(s); | |
| })); | |
| }); | |
| transport_controller_->SubscribeStandardizedIceConnectionState( | |
| [this](PeerConnectionInterface::IceConnectionState s) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| signaling_thread()->PostTask( | |
| SafeTask(signaling_thread_safety_.flag(), [this, s]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| SetStandardizedIceConnectionState(s); | |
| })); | |
| }); | |
| transport_controller_->SubscribeIceGatheringState( | |
| [this](cricket::IceGatheringState s) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| signaling_thread()->PostTask( | |
| SafeTask(signaling_thread_safety_.flag(), [this, s]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| OnTransportControllerGatheringState(s); | |
| })); | |
| }); | |
| transport_controller_->SubscribeIceCandidateGathered( | |
| [this](const std::string& transport, | |
| const std::vector<cricket::Candidate>& candidates) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| signaling_thread()->PostTask( | |
| SafeTask(signaling_thread_safety_.flag(), | |
| [this, t = transport, c = candidates]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| OnTransportControllerCandidatesGathered(t, c); | |
| })); | |
| }); | |
| transport_controller_->SubscribeIceCandidateError( | |
| [this](const cricket::IceCandidateErrorEvent& event) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| signaling_thread()->PostTask( | |
| SafeTask(signaling_thread_safety_.flag(), [this, event = event]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| OnTransportControllerCandidateError(event); | |
| })); | |
| }); | |
| transport_controller_->SubscribeIceCandidatesRemoved( | |
| [this](const std::vector<cricket::Candidate>& c) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| signaling_thread()->PostTask( | |
| SafeTask(signaling_thread_safety_.flag(), [this, c = c]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| OnTransportControllerCandidatesRemoved(c); | |
| })); | |
| }); | |
| transport_controller_->SubscribeIceCandidatePairChanged( | |
| [this](const cricket::CandidatePairChangeEvent& event) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| signaling_thread()->PostTask( | |
| SafeTask(signaling_thread_safety_.flag(), [this, event = event]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| OnTransportControllerCandidateChanged(event); | |
| })); | |
| }); | |
| transport_controller_->SetIceConfig(ParseIceConfig(configuration)); | |
| return transport_controller_.get(); | |
| } | |
| rtc::scoped_refptr<StreamCollectionInterface> PeerConnection::local_streams() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_CHECK(!IsUnifiedPlan()) << "local_streams is not available with Unified " | |
| "Plan SdpSemantics. Please use GetSenders " | |
| "instead."; | |
| return sdp_handler_->local_streams(); | |
| } | |
| rtc::scoped_refptr<StreamCollectionInterface> PeerConnection::remote_streams() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_CHECK(!IsUnifiedPlan()) << "remote_streams is not available with Unified " | |
| "Plan SdpSemantics. Please use GetReceivers " | |
| "instead."; | |
| return sdp_handler_->remote_streams(); | |
| } | |
| bool PeerConnection::AddStream(MediaStreamInterface* local_stream) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_CHECK(!IsUnifiedPlan()) << "AddStream is not available with Unified Plan " | |
| "SdpSemantics. Please use AddTrack instead."; | |
| TRACE_EVENT0("webrtc", "PeerConnection::AddStream"); | |
| if (!ConfiguredForMedia()) { | |
| RTC_LOG(LS_ERROR) << "AddStream: Not configured for media"; | |
| return false; | |
| } | |
| return sdp_handler_->AddStream(local_stream); | |
| } | |
| void PeerConnection::RemoveStream(MediaStreamInterface* local_stream) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_DCHECK(ConfiguredForMedia()); | |
| RTC_CHECK(!IsUnifiedPlan()) << "RemoveStream is not available with Unified " | |
| "Plan SdpSemantics. Please use RemoveTrack " | |
| "instead."; | |
| TRACE_EVENT0("webrtc", "PeerConnection::RemoveStream"); | |
| sdp_handler_->RemoveStream(local_stream); | |
| } | |
| RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::AddTrack( | |
| rtc::scoped_refptr<MediaStreamTrackInterface> track, | |
| const std::vector<std::string>& stream_ids) { | |
| return AddTrack(std::move(track), stream_ids, nullptr); | |
| } | |
| 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) { | |
| return AddTrack(std::move(track), stream_ids, &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) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| TRACE_EVENT0("webrtc", "PeerConnection::AddTrack"); | |
| if (!ConfiguredForMedia()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION, | |
| "Not configured for media"); | |
| } | |
| if (!track) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, "Track is null."); | |
| } | |
| if (!(track->kind() == MediaStreamTrackInterface::kAudioKind || | |
| track->kind() == MediaStreamTrackInterface::kVideoKind)) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, | |
| "Track has invalid kind: " + track->kind()); | |
| } | |
| if (IsClosed()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE, | |
| "PeerConnection is closed."); | |
| } | |
| if (rtp_manager()->FindSenderForTrack(track.get())) { | |
| LOG_AND_RETURN_ERROR( | |
| RTCErrorType::INVALID_PARAMETER, | |
| "Sender already exists for track " + track->id() + "."); | |
| } | |
| auto sender_or_error = | |
| rtp_manager()->AddTrack(track, stream_ids, init_send_encodings); | |
| if (sender_or_error.ok()) { | |
| sdp_handler_->UpdateNegotiationNeeded(); | |
| legacy_stats_->AddTrack(track.get()); | |
| } | |
| return sender_or_error; | |
| } | |
| RTCError PeerConnection::RemoveTrackOrError( | |
| rtc::scoped_refptr<RtpSenderInterface> sender) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (!ConfiguredForMedia()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION, | |
| "Not configured for media"); | |
| } | |
| if (!sender) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, "Sender is null."); | |
| } | |
| if (IsClosed()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE, | |
| "PeerConnection is closed."); | |
| } | |
| if (IsUnifiedPlan()) { | |
| auto transceiver = FindTransceiverBySender(sender); | |
| if (!transceiver || !sender->track()) { | |
| return RTCError::OK(); | |
| } | |
| sender->SetTrack(nullptr); | |
| if (transceiver->direction() == RtpTransceiverDirection::kSendRecv) { | |
| transceiver->internal()->set_direction( | |
| RtpTransceiverDirection::kRecvOnly); | |
| } else if (transceiver->direction() == RtpTransceiverDirection::kSendOnly) { | |
| transceiver->internal()->set_direction( | |
| RtpTransceiverDirection::kInactive); | |
| } | |
| } else { | |
| bool removed; | |
| if (sender->media_type() == cricket::MEDIA_TYPE_AUDIO) { | |
| removed = rtp_manager()->GetAudioTransceiver()->internal()->RemoveSender( | |
| sender.get()); | |
| } else { | |
| RTC_DCHECK_EQ(cricket::MEDIA_TYPE_VIDEO, sender->media_type()); | |
| removed = rtp_manager()->GetVideoTransceiver()->internal()->RemoveSender( | |
| sender.get()); | |
| } | |
| if (!removed) { | |
| LOG_AND_RETURN_ERROR( | |
| RTCErrorType::INVALID_PARAMETER, | |
| "Couldn't find sender " + sender->id() + " to remove."); | |
| } | |
| } | |
| sdp_handler_->UpdateNegotiationNeeded(); | |
| return RTCError::OK(); | |
| } | |
| rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>> | |
| PeerConnection::FindTransceiverBySender( | |
| rtc::scoped_refptr<RtpSenderInterface> sender) { | |
| return rtp_manager()->transceivers()->FindBySender(sender); | |
| } | |
| RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> | |
| PeerConnection::AddTransceiver( | |
| rtc::scoped_refptr<MediaStreamTrackInterface> track) { | |
| if (!ConfiguredForMedia()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION, | |
| "Not configured for media"); | |
| } | |
| return AddTransceiver(track, RtpTransceiverInit()); | |
| } | |
| RtpTransportInternal* PeerConnection::GetRtpTransport(const std::string& mid) { | |
| // TODO(bugs.webrtc.org/9987): Avoid the thread jump. | |
| // This might be done by caching the value on the signaling thread. | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return network_thread()->BlockingCall([this, &mid] { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| auto rtp_transport = transport_controller_->GetRtpTransport(mid); | |
| RTC_DCHECK(rtp_transport); | |
| return rtp_transport; | |
| }); | |
| } | |
| RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> | |
| PeerConnection::AddTransceiver( | |
| rtc::scoped_refptr<MediaStreamTrackInterface> track, | |
| const RtpTransceiverInit& init) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (!ConfiguredForMedia()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION, | |
| "Not configured for media"); | |
| } | |
| RTC_CHECK(IsUnifiedPlan()) | |
| << "AddTransceiver is only available with Unified Plan SdpSemantics"; | |
| if (!track) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, "track is null"); | |
| } | |
| cricket::MediaType media_type; | |
| if (track->kind() == MediaStreamTrackInterface::kAudioKind) { | |
| media_type = cricket::MEDIA_TYPE_AUDIO; | |
| } else if (track->kind() == MediaStreamTrackInterface::kVideoKind) { | |
| media_type = cricket::MEDIA_TYPE_VIDEO; | |
| } else { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, | |
| "Track kind is not audio or video"); | |
| } | |
| return AddTransceiver(media_type, track, init); | |
| } | |
| RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> | |
| PeerConnection::AddTransceiver(cricket::MediaType media_type) { | |
| return AddTransceiver(media_type, RtpTransceiverInit()); | |
| } | |
| RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> | |
| PeerConnection::AddTransceiver(cricket::MediaType media_type, | |
| const RtpTransceiverInit& init) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (!ConfiguredForMedia()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION, | |
| "Not configured for media"); | |
| } | |
| RTC_CHECK(IsUnifiedPlan()) | |
| << "AddTransceiver is only available with Unified Plan SdpSemantics"; | |
| if (!(media_type == cricket::MEDIA_TYPE_AUDIO || | |
| media_type == cricket::MEDIA_TYPE_VIDEO)) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, | |
| "media type is not audio or video"); | |
| } | |
| return AddTransceiver(media_type, nullptr, init); | |
| } | |
| RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> | |
| PeerConnection::AddTransceiver( | |
| cricket::MediaType media_type, | |
| rtc::scoped_refptr<MediaStreamTrackInterface> track, | |
| const RtpTransceiverInit& init, | |
| bool update_negotiation_needed) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (!ConfiguredForMedia()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION, | |
| "Not configured for media"); | |
| } | |
| RTC_DCHECK((media_type == cricket::MEDIA_TYPE_AUDIO || | |
| media_type == cricket::MEDIA_TYPE_VIDEO)); | |
| if (track) { | |
| RTC_DCHECK_EQ(media_type, | |
| (track->kind() == MediaStreamTrackInterface::kAudioKind | |
| ? cricket::MEDIA_TYPE_AUDIO | |
| : cricket::MEDIA_TYPE_VIDEO)); | |
| } | |
| RTC_HISTOGRAM_COUNTS_LINEAR(kSimulcastNumberOfEncodings, | |
| init.send_encodings.size(), 0, 7, 8); | |
| size_t num_rids = absl::c_count_if(init.send_encodings, | |
| [](const RtpEncodingParameters& encoding) { | |
| return !encoding.rid.empty(); | |
| }); | |
| if (num_rids > 0 && num_rids != init.send_encodings.size()) { | |
| LOG_AND_RETURN_ERROR( | |
| RTCErrorType::INVALID_PARAMETER, | |
| "RIDs must be provided for either all or none of the send encodings."); | |
| } | |
| if (num_rids > 0 && absl::c_any_of(init.send_encodings, | |
| [](const RtpEncodingParameters& encoding) { | |
| return !IsLegalRsidName(encoding.rid); | |
| })) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, | |
| "Invalid RID value provided."); | |
| } | |
| if (absl::c_any_of(init.send_encodings, | |
| [](const RtpEncodingParameters& encoding) { | |
| return encoding.ssrc.has_value(); | |
| })) { | |
| LOG_AND_RETURN_ERROR( | |
| RTCErrorType::UNSUPPORTED_PARAMETER, | |
| "Attempted to set an unimplemented parameter of RtpParameters."); | |
| } | |
| RtpParameters parameters; | |
| parameters.encodings = init.send_encodings; | |
| // Encodings are dropped from the tail if too many are provided. | |
| size_t max_simulcast_streams = | |
| media_type == cricket::MEDIA_TYPE_VIDEO ? kMaxSimulcastStreams : 1u; | |
| if (parameters.encodings.size() > max_simulcast_streams) { | |
| parameters.encodings.erase( | |
| parameters.encodings.begin() + max_simulcast_streams, | |
| parameters.encodings.end()); | |
| } | |
| // Single RID should be removed. | |
| if (parameters.encodings.size() == 1 && | |
| !parameters.encodings[0].rid.empty()) { | |
| RTC_LOG(LS_INFO) << "Removing RID: " << parameters.encodings[0].rid << "."; | |
| parameters.encodings[0].rid.clear(); | |
| } | |
| // If RIDs were not provided, they are generated for simulcast scenario. | |
| if (parameters.encodings.size() > 1 && num_rids == 0) { | |
| rtc::UniqueStringGenerator rid_generator; | |
| for (RtpEncodingParameters& encoding : parameters.encodings) { | |
| encoding.rid = rid_generator.GenerateString(); | |
| } | |
| } | |
| // If no encoding parameters were provided, a default entry is created. | |
| if (parameters.encodings.empty()) { | |
| parameters.encodings.push_back({}); | |
| } | |
| if (UnimplementedRtpParameterHasValue(parameters)) { | |
| LOG_AND_RETURN_ERROR( | |
| RTCErrorType::UNSUPPORTED_PARAMETER, | |
| "Attempted to set an unimplemented parameter of RtpParameters."); | |
| } | |
| std::vector<cricket::VideoCodec> codecs; | |
| // Gather the current codec capabilities to allow checking scalabilityMode and | |
| // codec selection against supported values. | |
| if (media_type == cricket::MEDIA_TYPE_VIDEO) { | |
| codecs = context_->media_engine()->video().send_codecs(false); | |
| } else { | |
| codecs = context_->media_engine()->voice().send_codecs(); | |
| } | |
| auto result = | |
| cricket::CheckRtpParametersValues(parameters, codecs, absl::nullopt); | |
| if (!result.ok()) { | |
| if (result.type() == RTCErrorType::INVALID_MODIFICATION) { | |
| result.set_type(RTCErrorType::UNSUPPORTED_OPERATION); | |
| } | |
| LOG_AND_RETURN_ERROR(result.type(), result.message()); | |
| } | |
| RTC_LOG(LS_INFO) << "Adding " << cricket::MediaTypeToString(media_type) | |
| << " transceiver in response to a call to AddTransceiver."; | |
| // Set the sender ID equal to the track ID if the track is specified unless | |
| // that sender ID is already in use. | |
| std::string sender_id = (track && !rtp_manager()->FindSenderById(track->id()) | |
| ? track->id() | |
| : rtc::CreateRandomUuid()); | |
| auto sender = rtp_manager()->CreateSender( | |
| media_type, sender_id, track, init.stream_ids, parameters.encodings); | |
| auto receiver = | |
| rtp_manager()->CreateReceiver(media_type, rtc::CreateRandomUuid()); | |
| auto transceiver = rtp_manager()->CreateAndAddTransceiver(sender, receiver); | |
| transceiver->internal()->set_direction(init.direction); | |
| if (update_negotiation_needed) { | |
| sdp_handler_->UpdateNegotiationNeeded(); | |
| } | |
| return rtc::scoped_refptr<RtpTransceiverInterface>(transceiver); | |
| } | |
| void PeerConnection::OnNegotiationNeeded() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_DCHECK(!IsClosed()); | |
| sdp_handler_->UpdateNegotiationNeeded(); | |
| } | |
| rtc::scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender( | |
| const std::string& kind, | |
| const std::string& stream_id) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (!ConfiguredForMedia()) { | |
| RTC_LOG(LS_ERROR) << "Not configured for media"; | |
| return nullptr; | |
| } | |
| RTC_CHECK(!IsUnifiedPlan()) << "CreateSender is not available with Unified " | |
| "Plan SdpSemantics. Please use AddTransceiver " | |
| "instead."; | |
| TRACE_EVENT0("webrtc", "PeerConnection::CreateSender"); | |
| if (IsClosed()) { | |
| return nullptr; | |
| } | |
| // Internally we need to have one stream with Plan B semantics, so we | |
| // generate a random stream ID if not specified. | |
| std::vector<std::string> stream_ids; | |
| if (stream_id.empty()) { | |
| stream_ids.push_back(rtc::CreateRandomUuid()); | |
| RTC_LOG(LS_INFO) | |
| << "No stream_id specified for sender. Generated stream ID: " | |
| << stream_ids[0]; | |
| } else { | |
| stream_ids.push_back(stream_id); | |
| } | |
| // TODO(steveanton): Move construction of the RtpSenders to RtpTransceiver. | |
| rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> new_sender; | |
| if (kind == MediaStreamTrackInterface::kAudioKind) { | |
| auto audio_sender = | |
| AudioRtpSender::Create(worker_thread(), rtc::CreateRandomUuid(), | |
| legacy_stats_.get(), rtp_manager()); | |
| audio_sender->SetMediaChannel(rtp_manager()->voice_media_send_channel()); | |
| new_sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create( | |
| signaling_thread(), audio_sender); | |
| rtp_manager()->GetAudioTransceiver()->internal()->AddSender(new_sender); | |
| } else if (kind == MediaStreamTrackInterface::kVideoKind) { | |
| auto video_sender = VideoRtpSender::Create( | |
| worker_thread(), rtc::CreateRandomUuid(), rtp_manager()); | |
| video_sender->SetMediaChannel(rtp_manager()->video_media_send_channel()); | |
| new_sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create( | |
| signaling_thread(), video_sender); | |
| rtp_manager()->GetVideoTransceiver()->internal()->AddSender(new_sender); | |
| } else { | |
| RTC_LOG(LS_ERROR) << "CreateSender called with invalid kind: " << kind; | |
| return nullptr; | |
| } | |
| new_sender->internal()->set_stream_ids(stream_ids); | |
| return new_sender; | |
| } | |
| std::vector<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::GetSenders() | |
| const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| std::vector<rtc::scoped_refptr<RtpSenderInterface>> ret; | |
| if (ConfiguredForMedia()) { | |
| for (const auto& sender : rtp_manager()->GetSendersInternal()) { | |
| ret.push_back(sender); | |
| } | |
| } | |
| return ret; | |
| } | |
| std::vector<rtc::scoped_refptr<RtpReceiverInterface>> | |
| PeerConnection::GetReceivers() const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| std::vector<rtc::scoped_refptr<RtpReceiverInterface>> ret; | |
| if (ConfiguredForMedia()) { | |
| for (const auto& receiver : rtp_manager()->GetReceiversInternal()) { | |
| ret.push_back(receiver); | |
| } | |
| } | |
| return ret; | |
| } | |
| std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> | |
| PeerConnection::GetTransceivers() const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_CHECK(IsUnifiedPlan()) | |
| << "GetTransceivers is only supported with Unified Plan SdpSemantics."; | |
| std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> all_transceivers; | |
| if (ConfiguredForMedia()) { | |
| for (const auto& transceiver : rtp_manager()->transceivers()->List()) { | |
| all_transceivers.push_back(transceiver); | |
| } | |
| } | |
| return all_transceivers; | |
| } | |
| bool PeerConnection::GetStats(StatsObserver* observer, | |
| MediaStreamTrackInterface* track, | |
| StatsOutputLevel level) { | |
| TRACE_EVENT0("webrtc", "PeerConnection::GetStats (legacy)"); | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (!observer) { | |
| RTC_LOG(LS_ERROR) << "Legacy GetStats - observer is NULL."; | |
| return false; | |
| } | |
| RTC_LOG_THREAD_BLOCK_COUNT(); | |
| legacy_stats_->UpdateStats(level); | |
| RTC_DCHECK_BLOCK_COUNT_NO_MORE_THAN(4); | |
| // The LegacyStatsCollector is used to tell if a track is valid because it may | |
| // remember tracks that the PeerConnection previously removed. | |
| if (track && !legacy_stats_->IsValidTrack(track->id())) { | |
| RTC_LOG(LS_WARNING) << "Legacy GetStats is called with an invalid track: " | |
| << track->id(); | |
| return false; | |
| } | |
| message_handler_.PostGetStats(observer, legacy_stats_.get(), track); | |
| return true; | |
| } | |
| void PeerConnection::GetStats(RTCStatsCollectorCallback* callback) { | |
| TRACE_EVENT0("webrtc", "PeerConnection::GetStats"); | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_DCHECK(stats_collector_); | |
| RTC_DCHECK(callback); | |
| RTC_LOG_THREAD_BLOCK_COUNT(); | |
| stats_collector_->GetStatsReport( | |
| rtc::scoped_refptr<RTCStatsCollectorCallback>(callback)); | |
| RTC_DCHECK_BLOCK_COUNT_NO_MORE_THAN(2); | |
| } | |
| void PeerConnection::GetStats( | |
| rtc::scoped_refptr<RtpSenderInterface> selector, | |
| rtc::scoped_refptr<RTCStatsCollectorCallback> callback) { | |
| TRACE_EVENT0("webrtc", "PeerConnection::GetStats"); | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_DCHECK(callback); | |
| RTC_DCHECK(stats_collector_); | |
| RTC_LOG_THREAD_BLOCK_COUNT(); | |
| rtc::scoped_refptr<RtpSenderInternal> internal_sender; | |
| if (selector) { | |
| for (const auto& proxy_transceiver : | |
| rtp_manager()->transceivers()->List()) { | |
| for (const auto& proxy_sender : | |
| proxy_transceiver->internal()->senders()) { | |
| if (proxy_sender == selector) { | |
| internal_sender = proxy_sender->internal(); | |
| break; | |
| } | |
| } | |
| if (internal_sender) | |
| break; | |
| } | |
| } | |
| // If there is no `internal_sender` then `selector` is either null or does not | |
| // belong to the PeerConnection (in Plan B, senders can be removed from the | |
| // PeerConnection). This means that "all the stats objects representing the | |
| // selector" is an empty set. Invoking GetStatsReport() with a null selector | |
| // produces an empty stats report. | |
| stats_collector_->GetStatsReport(internal_sender, callback); | |
| RTC_DCHECK_BLOCK_COUNT_NO_MORE_THAN(2); | |
| } | |
| void PeerConnection::GetStats( | |
| rtc::scoped_refptr<RtpReceiverInterface> selector, | |
| rtc::scoped_refptr<RTCStatsCollectorCallback> callback) { | |
| TRACE_EVENT0("webrtc", "PeerConnection::GetStats"); | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_DCHECK(callback); | |
| RTC_DCHECK(stats_collector_); | |
| RTC_LOG_THREAD_BLOCK_COUNT(); | |
| rtc::scoped_refptr<RtpReceiverInternal> internal_receiver; | |
| if (selector) { | |
| for (const auto& proxy_transceiver : | |
| rtp_manager()->transceivers()->List()) { | |
| for (const auto& proxy_receiver : | |
| proxy_transceiver->internal()->receivers()) { | |
| if (proxy_receiver == selector) { | |
| internal_receiver = proxy_receiver->internal(); | |
| break; | |
| } | |
| } | |
| if (internal_receiver) | |
| break; | |
| } | |
| } | |
| // If there is no `internal_receiver` then `selector` is either null or does | |
| // not belong to the PeerConnection (in Plan B, receivers can be removed from | |
| // the PeerConnection). This means that "all the stats objects representing | |
| // the selector" is an empty set. Invoking GetStatsReport() with a null | |
| // selector produces an empty stats report. | |
| stats_collector_->GetStatsReport(internal_receiver, callback); | |
| RTC_DCHECK_BLOCK_COUNT_NO_MORE_THAN(2); | |
| } | |
| PeerConnectionInterface::SignalingState PeerConnection::signaling_state() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sdp_handler_->signaling_state(); | |
| } | |
| PeerConnectionInterface::IceConnectionState | |
| PeerConnection::ice_connection_state() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return ice_connection_state_; | |
| } | |
| PeerConnectionInterface::IceConnectionState | |
| PeerConnection::standardized_ice_connection_state() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return standardized_ice_connection_state_; | |
| } | |
| PeerConnectionInterface::PeerConnectionState | |
| PeerConnection::peer_connection_state() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return connection_state_; | |
| } | |
| PeerConnectionInterface::IceGatheringState | |
| PeerConnection::ice_gathering_state() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return ice_gathering_state_; | |
| } | |
| absl::optional<bool> PeerConnection::can_trickle_ice_candidates() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| const SessionDescriptionInterface* description = current_remote_description(); | |
| if (!description) { | |
| description = pending_remote_description(); | |
| } | |
| if (!description) { | |
| return absl::nullopt; | |
| } | |
| // TODO(bugs.webrtc.org/7443): Change to retrieve from session-level option. | |
| if (description->description()->transport_infos().size() < 1) { | |
| return absl::nullopt; | |
| } | |
| return description->description()->transport_infos()[0].description.HasOption( | |
| "trickle"); | |
| } | |
| RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>> | |
| PeerConnection::CreateDataChannelOrError(const std::string& label, | |
| const DataChannelInit* config) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| TRACE_EVENT0("webrtc", "PeerConnection::CreateDataChannel"); | |
| if (IsClosed()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE, | |
| "CreateDataChannelOrError: PeerConnection is closed."); | |
| } | |
| bool first_datachannel = !data_channel_controller_.HasUsedDataChannels(); | |
| InternalDataChannelInit internal_config; | |
| if (config) { | |
| internal_config = InternalDataChannelInit(*config); | |
| } | |
| internal_config.fallback_ssl_role = sdp_handler_->GuessSslRole(); | |
| RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>> ret = | |
| data_channel_controller_.InternalCreateDataChannelWithProxy( | |
| label, internal_config); | |
| if (!ret.ok()) { | |
| return ret.MoveError(); | |
| } | |
| rtc::scoped_refptr<DataChannelInterface> channel = ret.MoveValue(); | |
| // Check the onRenegotiationNeeded event (with plan-b backward compat) | |
| if (configuration_.sdp_semantics == SdpSemantics::kUnifiedPlan || | |
| (configuration_.sdp_semantics == SdpSemantics::kPlanB_DEPRECATED && | |
| first_datachannel)) { | |
| sdp_handler_->UpdateNegotiationNeeded(); | |
| } | |
| NoteUsageEvent(UsageEvent::DATA_ADDED); | |
| return channel; | |
| } | |
| void PeerConnection::RestartIce() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->RestartIce(); | |
| } | |
| void PeerConnection::CreateOffer(CreateSessionDescriptionObserver* observer, | |
| const RTCOfferAnswerOptions& options) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->CreateOffer(observer, options); | |
| } | |
| void PeerConnection::CreateAnswer(CreateSessionDescriptionObserver* observer, | |
| const RTCOfferAnswerOptions& options) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->CreateAnswer(observer, options); | |
| } | |
| void PeerConnection::SetLocalDescription( | |
| SetSessionDescriptionObserver* observer, | |
| SessionDescriptionInterface* desc_ptr) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->SetLocalDescription(observer, desc_ptr); | |
| } | |
| void PeerConnection::SetLocalDescription( | |
| std::unique_ptr<SessionDescriptionInterface> desc, | |
| rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->SetLocalDescription(std::move(desc), observer); | |
| } | |
| void PeerConnection::SetLocalDescription( | |
| SetSessionDescriptionObserver* observer) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->SetLocalDescription(observer); | |
| } | |
| void PeerConnection::SetLocalDescription( | |
| rtc::scoped_refptr<SetLocalDescriptionObserverInterface> observer) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->SetLocalDescription(observer); | |
| } | |
| void PeerConnection::SetRemoteDescription( | |
| SetSessionDescriptionObserver* observer, | |
| SessionDescriptionInterface* desc_ptr) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->SetRemoteDescription(observer, desc_ptr); | |
| } | |
| void PeerConnection::SetRemoteDescription( | |
| std::unique_ptr<SessionDescriptionInterface> desc, | |
| rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->SetRemoteDescription(std::move(desc), observer); | |
| } | |
| PeerConnectionInterface::RTCConfiguration PeerConnection::GetConfiguration() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return configuration_; | |
| } | |
| RTCError PeerConnection::SetConfiguration( | |
| const RTCConfiguration& configuration) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| TRACE_EVENT0("webrtc", "PeerConnection::SetConfiguration"); | |
| if (IsClosed()) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE, | |
| "SetConfiguration: PeerConnection is closed."); | |
| } | |
| const bool has_local_description = local_description() != nullptr; | |
| RTCError validate_error = ValidateIceCandidatePoolSize( | |
| configuration.ice_candidate_pool_size, | |
| has_local_description | |
| ? absl::optional<int>(configuration_.ice_candidate_pool_size) | |
| : absl::nullopt); | |
| if (!validate_error.ok()) { | |
| return validate_error; | |
| } | |
| if (has_local_description && | |
| configuration.crypto_options != configuration_.crypto_options) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_MODIFICATION, | |
| "Can't change crypto_options after calling " | |
| "SetLocalDescription."); | |
| } | |
| // Create a new, configuration object whose Ice config will have been | |
| // validated.. | |
| RTCErrorOr<RTCConfiguration> validated_config = | |
| ApplyConfiguration(configuration, configuration_); | |
| if (!validated_config.ok()) { | |
| return validated_config.error(); | |
| } | |
| // Parse ICE servers before hopping to network thread. | |
| cricket::ServerAddresses stun_servers; | |
| std::vector<cricket::RelayServerConfig> turn_servers; | |
| validate_error = ParseAndValidateIceServersFromConfiguration( | |
| configuration, stun_servers, turn_servers, usage_pattern_); | |
| if (!validate_error.ok()) { | |
| return validate_error; | |
| } | |
| const RTCConfiguration& modified_config = validated_config.value(); | |
| const bool needs_ice_restart = | |
| modified_config.servers != configuration_.servers || | |
| NeedIceRestart( | |
| configuration_.surface_ice_candidates_on_ice_transport_type_changed, | |
| configuration_.type, modified_config.type) || | |
| modified_config.GetTurnPortPrunePolicy() != | |
| configuration_.GetTurnPortPrunePolicy(); | |
| cricket::IceConfig ice_config = ParseIceConfig(modified_config); | |
| // Apply part of the configuration on the network thread. In theory this | |
| // shouldn't fail. | |
| if (!network_thread()->BlockingCall( | |
| [this, needs_ice_restart, &ice_config, &stun_servers, &turn_servers, | |
| &modified_config, has_local_description] { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| // As described in JSEP, calling setConfiguration with new ICE | |
| // servers or candidate policy must set a "needs-ice-restart" bit so | |
| // that the next offer triggers an ICE restart which will pick up | |
| // the changes. | |
| if (needs_ice_restart) | |
| transport_controller_->SetNeedsIceRestartFlag(); | |
| transport_controller_->SetIceConfig(ice_config); | |
| transport_controller_->SetActiveResetSrtpParams( | |
| modified_config.active_reset_srtp_params); | |
| return ReconfigurePortAllocator_n( | |
| stun_servers, turn_servers, modified_config.type, | |
| modified_config.ice_candidate_pool_size, | |
| modified_config.GetTurnPortPrunePolicy(), | |
| modified_config.turn_customizer, | |
| modified_config.stun_candidate_keepalive_interval, | |
| has_local_description); | |
| })) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INTERNAL_ERROR, | |
| "Failed to apply configuration to PortAllocator."); | |
| } | |
| configuration_ = modified_config; | |
| return RTCError::OK(); | |
| } | |
| bool PeerConnection::AddIceCandidate( | |
| const IceCandidateInterface* ice_candidate) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| ClearStatsCache(); | |
| return sdp_handler_->AddIceCandidate(ice_candidate); | |
| } | |
| void PeerConnection::AddIceCandidate( | |
| std::unique_ptr<IceCandidateInterface> candidate, | |
| std::function<void(RTCError)> callback) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sdp_handler_->AddIceCandidate(std::move(candidate), | |
| [this, callback](RTCError result) { | |
| ClearStatsCache(); | |
| callback(result); | |
| }); | |
| } | |
| bool PeerConnection::RemoveIceCandidates( | |
| const std::vector<cricket::Candidate>& candidates) { | |
| TRACE_EVENT0("webrtc", "PeerConnection::RemoveIceCandidates"); | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sdp_handler_->RemoveIceCandidates(candidates); | |
| } | |
| RTCError PeerConnection::SetBitrate(const BitrateSettings& bitrate) { | |
| if (!worker_thread()->IsCurrent()) { | |
| return worker_thread()->BlockingCall([&]() { return SetBitrate(bitrate); }); | |
| } | |
| RTC_DCHECK_RUN_ON(worker_thread()); | |
| const bool has_min = bitrate.min_bitrate_bps.has_value(); | |
| const bool has_start = bitrate.start_bitrate_bps.has_value(); | |
| const bool has_max = bitrate.max_bitrate_bps.has_value(); | |
| if (has_min && *bitrate.min_bitrate_bps < 0) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, | |
| "min_bitrate_bps <= 0"); | |
| } | |
| if (has_start) { | |
| if (has_min && *bitrate.start_bitrate_bps < *bitrate.min_bitrate_bps) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, | |
| "start_bitrate_bps < min_bitrate_bps"); | |
| } else if (*bitrate.start_bitrate_bps < 0) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, | |
| "curent_bitrate_bps < 0"); | |
| } | |
| } | |
| if (has_max) { | |
| if (has_start && *bitrate.max_bitrate_bps < *bitrate.start_bitrate_bps) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, | |
| "max_bitrate_bps < start_bitrate_bps"); | |
| } else if (has_min && *bitrate.max_bitrate_bps < *bitrate.min_bitrate_bps) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, | |
| "max_bitrate_bps < min_bitrate_bps"); | |
| } else if (*bitrate.max_bitrate_bps < 0) { | |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, | |
| "max_bitrate_bps < 0"); | |
| } | |
| } | |
| RTC_DCHECK(call_.get()); | |
| call_->SetClientBitratePreferences(bitrate); | |
| return RTCError::OK(); | |
| } | |
| void PeerConnection::SetAudioPlayout(bool playout) { | |
| if (!worker_thread()->IsCurrent()) { | |
| worker_thread()->BlockingCall( | |
| [this, playout] { SetAudioPlayout(playout); }); | |
| return; | |
| } | |
| auto audio_state = context_->media_engine()->voice().GetAudioState(); | |
| audio_state->SetPlayout(playout); | |
| } | |
| void PeerConnection::SetAudioRecording(bool recording) { | |
| if (!worker_thread()->IsCurrent()) { | |
| worker_thread()->BlockingCall( | |
| [this, recording] { SetAudioRecording(recording); }); | |
| return; | |
| } | |
| auto audio_state = context_->media_engine()->voice().GetAudioState(); | |
| audio_state->SetRecording(recording); | |
| } | |
| void PeerConnection::AddAdaptationResource( | |
| rtc::scoped_refptr<Resource> resource) { | |
| if (!worker_thread()->IsCurrent()) { | |
| return worker_thread()->BlockingCall( | |
| [this, resource]() { return AddAdaptationResource(resource); }); | |
| } | |
| RTC_DCHECK_RUN_ON(worker_thread()); | |
| if (!call_) { | |
| // The PeerConnection has been closed. | |
| return; | |
| } | |
| call_->AddAdaptationResource(resource); | |
| } | |
| bool PeerConnection::ConfiguredForMedia() const { | |
| return context_->media_engine(); | |
| } | |
| bool PeerConnection::StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output, | |
| int64_t output_period_ms) { | |
| return worker_thread()->BlockingCall( | |
| [this, output = std::move(output), output_period_ms]() mutable { | |
| return StartRtcEventLog_w(std::move(output), output_period_ms); | |
| }); | |
| } | |
| bool PeerConnection::StartRtcEventLog( | |
| std::unique_ptr<RtcEventLogOutput> output) { | |
| int64_t output_period_ms = 5000; | |
| if (trials().IsDisabled("WebRTC-RtcEventLogNewFormat")) { | |
| output_period_ms = RtcEventLog::kImmediateOutput; | |
| } | |
| return StartRtcEventLog(std::move(output), output_period_ms); | |
| } | |
| void PeerConnection::StopRtcEventLog() { | |
| worker_thread()->BlockingCall([this] { StopRtcEventLog_w(); }); | |
| } | |
| rtc::scoped_refptr<DtlsTransportInterface> | |
| PeerConnection::LookupDtlsTransportByMid(const std::string& mid) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| return transport_controller_->LookupDtlsTransportByMid(mid); | |
| } | |
| rtc::scoped_refptr<DtlsTransport> | |
| PeerConnection::LookupDtlsTransportByMidInternal(const std::string& mid) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| // TODO(bugs.webrtc.org/9987): Avoid the thread jump. | |
| // This might be done by caching the value on the signaling thread. | |
| return network_thread()->BlockingCall([this, mid]() { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| return transport_controller_->LookupDtlsTransportByMid(mid); | |
| }); | |
| } | |
| rtc::scoped_refptr<SctpTransportInterface> PeerConnection::GetSctpTransport() | |
| const { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| if (!sctp_mid_n_) | |
| return nullptr; | |
| return transport_controller_->GetSctpTransport(*sctp_mid_n_); | |
| } | |
| const SessionDescriptionInterface* PeerConnection::local_description() const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sdp_handler_->local_description(); | |
| } | |
| const SessionDescriptionInterface* PeerConnection::remote_description() const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sdp_handler_->remote_description(); | |
| } | |
| const SessionDescriptionInterface* PeerConnection::current_local_description() | |
| const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sdp_handler_->current_local_description(); | |
| } | |
| const SessionDescriptionInterface* PeerConnection::current_remote_description() | |
| const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sdp_handler_->current_remote_description(); | |
| } | |
| const SessionDescriptionInterface* PeerConnection::pending_local_description() | |
| const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sdp_handler_->pending_local_description(); | |
| } | |
| const SessionDescriptionInterface* PeerConnection::pending_remote_description() | |
| const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sdp_handler_->pending_remote_description(); | |
| } | |
| void PeerConnection::Close() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| TRACE_EVENT0("webrtc", "PeerConnection::Close"); | |
| RTC_LOG_THREAD_BLOCK_COUNT(); | |
| if (IsClosed()) { | |
| return; | |
| } | |
| // Update stats here so that we have the most recent stats for tracks and | |
| // streams before the channels are closed. | |
| legacy_stats_->UpdateStats(kStatsOutputLevelStandard); | |
| ice_connection_state_ = PeerConnectionInterface::kIceConnectionClosed; | |
| Observer()->OnIceConnectionChange(ice_connection_state_); | |
| standardized_ice_connection_state_ = | |
| PeerConnectionInterface::IceConnectionState::kIceConnectionClosed; | |
| connection_state_ = PeerConnectionInterface::PeerConnectionState::kClosed; | |
| Observer()->OnConnectionChange(connection_state_); | |
| sdp_handler_->Close(); | |
| NoteUsageEvent(UsageEvent::CLOSE_CALLED); | |
| if (ConfiguredForMedia()) { | |
| for (const auto& transceiver : rtp_manager()->transceivers()->List()) { | |
| transceiver->internal()->SetPeerConnectionClosed(); | |
| if (!transceiver->stopped()) | |
| transceiver->StopInternal(); | |
| } | |
| } | |
| // Ensure that all asynchronous stats requests are completed before destroying | |
| // the transport controller below. | |
| if (stats_collector_) { | |
| stats_collector_->WaitForPendingRequest(); | |
| } | |
| // Don't destroy BaseChannels until after stats has been cleaned up so that | |
| // the last stats request can still read from the channels. | |
| // TODO(tommi): The voice/video channels will be partially uninitialized on | |
| // the network thread (see `RtpTransceiver::ClearChannel`), partially on the | |
| // worker thread (see `PushNewMediaChannelAndDeleteChannel`) and then | |
| // eventually freed on the signaling thread. | |
| // It would be good to combine those steps with the teardown steps here. | |
| sdp_handler_->DestroyMediaChannels(); | |
| // The event log is used in the transport controller, which must be outlived | |
| // by the former. CreateOffer by the peer connection is implemented | |
| // asynchronously and if the peer connection is closed without resetting the | |
| // WebRTC session description factory, the session description factory would | |
| // call the transport controller. | |
| sdp_handler_->ResetSessionDescFactory(); | |
| if (ConfiguredForMedia()) { | |
| rtp_manager_->Close(); | |
| } | |
| network_thread()->BlockingCall([this] { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| TeardownDataChannelTransport_n({}); | |
| transport_controller_.reset(); | |
| port_allocator_->DiscardCandidatePool(); | |
| if (network_thread_safety_) { | |
| network_thread_safety_->SetNotAlive(); | |
| } | |
| }); | |
| sctp_mid_s_.reset(); | |
| SetSctpTransportName(""); | |
| worker_thread()->BlockingCall([this] { | |
| RTC_DCHECK_RUN_ON(worker_thread()); | |
| worker_thread_safety_->SetNotAlive(); | |
| call_.reset(); | |
| // The event log must outlive call (and any other object that uses it). | |
| event_log_.reset(); | |
| }); | |
| ReportUsagePattern(); | |
| // Signal shutdown to the sdp handler. This invalidates weak pointers for | |
| // internal pending callbacks. | |
| sdp_handler_->PrepareForShutdown(); | |
| data_channel_controller_.PrepareForShutdown(); | |
| // The .h file says that observer can be discarded after close() returns. | |
| // Make sure this is true. | |
| observer_ = nullptr; | |
| } | |
| void PeerConnection::SetIceConnectionState(IceConnectionState new_state) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (ice_connection_state_ == new_state) { | |
| return; | |
| } | |
| // After transitioning to "closed", ignore any additional states from | |
| // TransportController (such as "disconnected"). | |
| if (IsClosed()) { | |
| return; | |
| } | |
| RTC_LOG(LS_INFO) << "Changing IceConnectionState " << ice_connection_state_ | |
| << " => " << new_state; | |
| RTC_DCHECK(ice_connection_state_ != | |
| PeerConnectionInterface::kIceConnectionClosed); | |
| ice_connection_state_ = new_state; | |
| Observer()->OnIceConnectionChange(ice_connection_state_); | |
| } | |
| void PeerConnection::SetStandardizedIceConnectionState( | |
| PeerConnectionInterface::IceConnectionState new_state) { | |
| if (standardized_ice_connection_state_ == new_state) { | |
| return; | |
| } | |
| if (IsClosed()) { | |
| return; | |
| } | |
| RTC_LOG(LS_INFO) << "Changing standardized IceConnectionState " | |
| << standardized_ice_connection_state_ << " => " << new_state; | |
| standardized_ice_connection_state_ = new_state; | |
| Observer()->OnStandardizedIceConnectionChange(new_state); | |
| } | |
| void PeerConnection::SetConnectionState( | |
| PeerConnectionInterface::PeerConnectionState new_state) { | |
| if (connection_state_ == new_state) | |
| return; | |
| if (IsClosed()) | |
| return; | |
| connection_state_ = new_state; | |
| Observer()->OnConnectionChange(new_state); | |
| // The first connection state change to connected happens once per | |
| // connection which makes it a good point to report metrics. | |
| if (new_state == PeerConnectionState::kConnected && !was_ever_connected_) { | |
| was_ever_connected_ = true; | |
| ReportFirstConnectUsageMetrics(); | |
| } | |
| } | |
| void PeerConnection::ReportFirstConnectUsageMetrics() { | |
| // Record bundle-policy from configuration. Done here from | |
| // connectionStateChange to limit to actually established connections. | |
| BundlePolicyUsage policy = kBundlePolicyUsageMax; | |
| switch (configuration_.bundle_policy) { | |
| case kBundlePolicyBalanced: | |
| policy = kBundlePolicyUsageBalanced; | |
| break; | |
| case kBundlePolicyMaxBundle: | |
| policy = kBundlePolicyUsageMaxBundle; | |
| break; | |
| case kBundlePolicyMaxCompat: | |
| policy = kBundlePolicyUsageMaxCompat; | |
| break; | |
| } | |
| RTC_HISTOGRAM_ENUMERATION("WebRTC.PeerConnection.BundlePolicy", policy, | |
| kBundlePolicyUsageMax); | |
| // Record whether there was a local or remote provisional answer. | |
| ProvisionalAnswerUsage pranswer = kProvisionalAnswerNotUsed; | |
| if (local_description()->GetType() == SdpType::kPrAnswer) { | |
| pranswer = kProvisionalAnswerLocal; | |
| } else if (remote_description()->GetType() == SdpType::kPrAnswer) { | |
| pranswer = kProvisionalAnswerRemote; | |
| } | |
| RTC_HISTOGRAM_ENUMERATION("WebRTC.PeerConnection.ProvisionalAnswer", pranswer, | |
| kProvisionalAnswerMax); | |
| auto transport_infos = remote_description()->description()->transport_infos(); | |
| if (!transport_infos.empty()) { | |
| // Record the number of valid / invalid ice-ufrag. We do allow certain | |
| // non-spec ice-char for backward-compat reasons. At this point we know | |
| // that the ufrag/pwd consists of a valid ice-char or one of the four | |
| // not allowed characters since we have passed the IsIceChar check done | |
| // by the p2p transport description on setRemoteDescription calls. | |
| auto ice_parameters = transport_infos[0].description.GetIceParameters(); | |
| auto is_invalid_char = [](char c) { | |
| return c == '-' || c == '=' || c == '#' || c == '_'; | |
| }; | |
| bool isUsingInvalidIceCharInUfrag = | |
| absl::c_any_of(ice_parameters.ufrag, is_invalid_char); | |
| bool isUsingInvalidIceCharInPwd = | |
| absl::c_any_of(ice_parameters.pwd, is_invalid_char); | |
| RTC_HISTOGRAM_BOOLEAN( | |
| "WebRTC.PeerConnection.ValidIceChars", | |
| !(isUsingInvalidIceCharInUfrag || isUsingInvalidIceCharInPwd)); | |
| // Record whether the hash algorithm of the first transport's | |
| // DTLS fingerprint is still using SHA-1. | |
| if (transport_infos[0].description.identity_fingerprint) { | |
| RTC_HISTOGRAM_BOOLEAN( | |
| "WebRTC.PeerConnection.DtlsFingerprintLegacySha1", | |
| absl::EqualsIgnoreCase( | |
| transport_infos[0].description.identity_fingerprint->algorithm, | |
| "sha-1")); | |
| } | |
| } | |
| // Record RtcpMuxPolicy setting. | |
| RtcpMuxPolicyUsage rtcp_mux_policy = kRtcpMuxPolicyUsageMax; | |
| switch (configuration_.rtcp_mux_policy) { | |
| case kRtcpMuxPolicyNegotiate: | |
| rtcp_mux_policy = kRtcpMuxPolicyUsageNegotiate; | |
| break; | |
| case kRtcpMuxPolicyRequire: | |
| rtcp_mux_policy = kRtcpMuxPolicyUsageRequire; | |
| break; | |
| } | |
| RTC_HISTOGRAM_ENUMERATION("WebRTC.PeerConnection.RtcpMuxPolicy", | |
| rtcp_mux_policy, kRtcpMuxPolicyUsageMax); | |
| } | |
| void PeerConnection::OnIceGatheringChange( | |
| PeerConnectionInterface::IceGatheringState new_state) { | |
| if (IsClosed()) { | |
| return; | |
| } | |
| ice_gathering_state_ = new_state; | |
| Observer()->OnIceGatheringChange(ice_gathering_state_); | |
| } | |
| void PeerConnection::OnIceCandidate( | |
| std::unique_ptr<IceCandidateInterface> candidate) { | |
| if (IsClosed()) { | |
| return; | |
| } | |
| ReportIceCandidateCollected(candidate->candidate()); | |
| ClearStatsCache(); | |
| Observer()->OnIceCandidate(candidate.get()); | |
| } | |
| void PeerConnection::OnIceCandidateError(const std::string& address, | |
| int port, | |
| const std::string& url, | |
| int error_code, | |
| const std::string& error_text) { | |
| if (IsClosed()) { | |
| return; | |
| } | |
| Observer()->OnIceCandidateError(address, port, url, error_code, error_text); | |
| } | |
| void PeerConnection::OnIceCandidatesRemoved( | |
| const std::vector<cricket::Candidate>& candidates) { | |
| if (IsClosed()) { | |
| return; | |
| } | |
| Observer()->OnIceCandidatesRemoved(candidates); | |
| } | |
| void PeerConnection::OnSelectedCandidatePairChanged( | |
| const cricket::CandidatePairChangeEvent& event) { | |
| if (IsClosed()) { | |
| return; | |
| } | |
| if (event.selected_candidate_pair.local_candidate().type() == | |
| LOCAL_PORT_TYPE && | |
| event.selected_candidate_pair.remote_candidate().type() == | |
| LOCAL_PORT_TYPE) { | |
| NoteUsageEvent(UsageEvent::DIRECT_CONNECTION_SELECTED); | |
| } | |
| Observer()->OnIceSelectedCandidatePairChanged(event); | |
| } | |
| bool PeerConnection::CreateDataChannelTransport(absl::string_view mid) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_DCHECK(!sctp_mid().has_value() || mid == sctp_mid().value()); | |
| RTC_LOG(LS_INFO) << "Creating data channel, mid=" << mid; | |
| absl::optional<std::string> transport_name = | |
| network_thread()->BlockingCall([&] { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| return SetupDataChannelTransport_n(mid); | |
| }); | |
| if (!transport_name) | |
| return false; | |
| sctp_mid_s_ = std::string(mid); | |
| SetSctpTransportName(transport_name.value()); | |
| return true; | |
| } | |
| void PeerConnection::DestroyDataChannelTransport(RTCError error) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| network_thread()->BlockingCall([&] { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| TeardownDataChannelTransport_n(error); | |
| }); | |
| sctp_mid_s_.reset(); | |
| SetSctpTransportName(""); | |
| } | |
| void PeerConnection::OnSctpDataChannelStateChanged( | |
| int channel_id, | |
| DataChannelInterface::DataState state) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (stats_collector_) | |
| stats_collector_->OnSctpDataChannelStateChanged(channel_id, state); | |
| } | |
| PeerConnection::InitializePortAllocatorResult | |
| PeerConnection::InitializePortAllocator_n( | |
| const cricket::ServerAddresses& stun_servers, | |
| const std::vector<cricket::RelayServerConfig>& turn_servers, | |
| const RTCConfiguration& configuration) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| port_allocator_->Initialize(); | |
| // To handle both internal and externally created port allocator, we will | |
| // enable BUNDLE here. | |
| int port_allocator_flags = port_allocator_->flags(); | |
| port_allocator_flags |= cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET | | |
| cricket::PORTALLOCATOR_ENABLE_IPV6 | | |
| cricket::PORTALLOCATOR_ENABLE_IPV6_ON_WIFI; | |
| if (trials().IsDisabled("WebRTC-IPv6Default")) { | |
| port_allocator_flags &= ~(cricket::PORTALLOCATOR_ENABLE_IPV6); | |
| } | |
| if (configuration.disable_ipv6_on_wifi) { | |
| port_allocator_flags &= ~(cricket::PORTALLOCATOR_ENABLE_IPV6_ON_WIFI); | |
| RTC_LOG(LS_INFO) << "IPv6 candidates on Wi-Fi are disabled."; | |
| } | |
| if (configuration.tcp_candidate_policy == kTcpCandidatePolicyDisabled) { | |
| port_allocator_flags |= cricket::PORTALLOCATOR_DISABLE_TCP; | |
| RTC_LOG(LS_INFO) << "TCP candidates are disabled."; | |
| } | |
| if (configuration.candidate_network_policy == | |
| kCandidateNetworkPolicyLowCost) { | |
| port_allocator_flags |= cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS; | |
| RTC_LOG(LS_INFO) << "Do not gather candidates on high-cost networks"; | |
| } | |
| if (configuration.disable_link_local_networks) { | |
| port_allocator_flags |= cricket::PORTALLOCATOR_DISABLE_LINK_LOCAL_NETWORKS; | |
| RTC_LOG(LS_INFO) << "Disable candidates on link-local network interfaces."; | |
| } | |
| port_allocator_->set_flags(port_allocator_flags); | |
| // No step delay is used while allocating ports. | |
| port_allocator_->set_step_delay(cricket::kMinimumStepDelay); | |
| port_allocator_->SetCandidateFilter( | |
| ConvertIceTransportTypeToCandidateFilter(configuration.type)); | |
| port_allocator_->set_max_ipv6_networks(configuration.max_ipv6_networks); | |
| auto turn_servers_copy = turn_servers; | |
| for (auto& turn_server : turn_servers_copy) { | |
| turn_server.tls_cert_verifier = tls_cert_verifier_.get(); | |
| } | |
| // Call this last since it may create pooled allocator sessions using the | |
| // properties set above. | |
| port_allocator_->SetConfiguration( | |
| stun_servers, std::move(turn_servers_copy), | |
| configuration.ice_candidate_pool_size, | |
| configuration.GetTurnPortPrunePolicy(), configuration.turn_customizer, | |
| configuration.stun_candidate_keepalive_interval); | |
| InitializePortAllocatorResult res; | |
| res.enable_ipv6 = port_allocator_flags & cricket::PORTALLOCATOR_ENABLE_IPV6; | |
| return res; | |
| } | |
| 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) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| port_allocator_->SetCandidateFilter( | |
| ConvertIceTransportTypeToCandidateFilter(type)); | |
| // Add the custom tls turn servers if they exist. | |
| auto turn_servers_copy = turn_servers; | |
| for (auto& turn_server : turn_servers_copy) { | |
| turn_server.tls_cert_verifier = tls_cert_verifier_.get(); | |
| } | |
| // Call this last since it may create pooled allocator sessions using the | |
| // candidate filter set above. | |
| return port_allocator_->SetConfiguration( | |
| stun_servers, std::move(turn_servers_copy), candidate_pool_size, | |
| turn_port_prune_policy, turn_customizer, | |
| stun_candidate_keepalive_interval); | |
| } | |
| bool PeerConnection::StartRtcEventLog_w( | |
| std::unique_ptr<RtcEventLogOutput> output, | |
| int64_t output_period_ms) { | |
| RTC_DCHECK_RUN_ON(worker_thread()); | |
| if (!event_log_) { | |
| return false; | |
| } | |
| return event_log_->StartLogging(std::move(output), output_period_ms); | |
| } | |
| void PeerConnection::StopRtcEventLog_w() { | |
| RTC_DCHECK_RUN_ON(worker_thread()); | |
| if (event_log_) { | |
| event_log_->StopLogging(); | |
| } | |
| } | |
| absl::optional<rtc::SSLRole> PeerConnection::GetSctpSslRole_n() { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| return sctp_mid_n_ ? transport_controller_->GetDtlsRole(*sctp_mid_n_) | |
| : absl::nullopt; | |
| } | |
| bool PeerConnection::GetSslRole(const std::string& content_name, | |
| rtc::SSLRole* role) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (!local_description() || !remote_description()) { | |
| RTC_LOG(LS_INFO) | |
| << "Local and Remote descriptions must be applied to get the " | |
| "SSL Role of the session."; | |
| return false; | |
| } | |
| auto dtls_role = network_thread()->BlockingCall([this, content_name]() { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| return transport_controller_->GetDtlsRole(content_name); | |
| }); | |
| if (dtls_role) { | |
| *role = *dtls_role; | |
| return true; | |
| } | |
| return false; | |
| } | |
| bool PeerConnection::GetTransportDescription( | |
| const SessionDescription* description, | |
| const std::string& content_name, | |
| cricket::TransportDescription* tdesc) { | |
| if (!description || !tdesc) { | |
| return false; | |
| } | |
| const TransportInfo* transport_info = | |
| description->GetTransportInfoByName(content_name); | |
| if (!transport_info) { | |
| return false; | |
| } | |
| *tdesc = transport_info->description; | |
| return true; | |
| } | |
| std::vector<DataChannelStats> PeerConnection::GetDataChannelStats() const { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| return data_channel_controller_.GetDataChannelStats(); | |
| } | |
| absl::optional<std::string> PeerConnection::sctp_transport_name() const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (sctp_mid_s_ && transport_controller_copy_) | |
| return sctp_transport_name_s_; | |
| return absl::optional<std::string>(); | |
| } | |
| void PeerConnection::SetSctpTransportName(std::string sctp_transport_name) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| sctp_transport_name_s_ = std::move(sctp_transport_name); | |
| ClearStatsCache(); | |
| } | |
| absl::optional<std::string> PeerConnection::sctp_mid() const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sctp_mid_s_; | |
| } | |
| cricket::CandidateStatsList PeerConnection::GetPooledCandidateStats() const { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| if (!network_thread_safety_->alive()) | |
| return {}; | |
| cricket::CandidateStatsList candidate_stats_list; | |
| port_allocator_->GetCandidateStatsFromPooledSessions(&candidate_stats_list); | |
| return candidate_stats_list; | |
| } | |
| std::map<std::string, cricket::TransportStats> | |
| PeerConnection::GetTransportStatsByNames( | |
| const std::set<std::string>& transport_names) { | |
| TRACE_EVENT0("webrtc", "PeerConnection::GetTransportStatsByNames"); | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| if (!network_thread_safety_->alive()) | |
| return {}; | |
| rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls; | |
| std::map<std::string, cricket::TransportStats> transport_stats_by_name; | |
| for (const std::string& transport_name : transport_names) { | |
| cricket::TransportStats transport_stats; | |
| bool success = | |
| transport_controller_->GetStats(transport_name, &transport_stats); | |
| if (success) { | |
| transport_stats_by_name[transport_name] = std::move(transport_stats); | |
| } else { | |
| RTC_LOG(LS_ERROR) << "Failed to get transport stats for transport_name=" | |
| << transport_name; | |
| } | |
| } | |
| return transport_stats_by_name; | |
| } | |
| bool PeerConnection::GetLocalCertificate( | |
| const std::string& transport_name, | |
| rtc::scoped_refptr<rtc::RTCCertificate>* certificate) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| if (!network_thread_safety_->alive() || !certificate) { | |
| return false; | |
| } | |
| *certificate = transport_controller_->GetLocalCertificate(transport_name); | |
| return *certificate != nullptr; | |
| } | |
| std::unique_ptr<rtc::SSLCertChain> PeerConnection::GetRemoteSSLCertChain( | |
| const std::string& transport_name) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| return transport_controller_->GetRemoteSSLCertChain(transport_name); | |
| } | |
| bool PeerConnection::IceRestartPending(const std::string& content_name) const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sdp_handler_->IceRestartPending(content_name); | |
| } | |
| bool PeerConnection::NeedsIceRestart(const std::string& content_name) const { | |
| return network_thread()->BlockingCall([this, &content_name] { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| return transport_controller_->NeedsIceRestart(content_name); | |
| }); | |
| } | |
| void PeerConnection::OnTransportControllerConnectionState( | |
| cricket::IceConnectionState state) { | |
| switch (state) { | |
| case cricket::kIceConnectionConnecting: | |
| // If the current state is Connected or Completed, then there were | |
| // writable channels but now there are not, so the next state must | |
| // be Disconnected. | |
| // kIceConnectionConnecting is currently used as the default, | |
| // un-connected state by the TransportController, so its only use is | |
| // detecting disconnections. | |
| if (ice_connection_state_ == | |
| PeerConnectionInterface::kIceConnectionConnected || | |
| ice_connection_state_ == | |
| PeerConnectionInterface::kIceConnectionCompleted) { | |
| SetIceConnectionState( | |
| PeerConnectionInterface::kIceConnectionDisconnected); | |
| } | |
| break; | |
| case cricket::kIceConnectionFailed: | |
| SetIceConnectionState(PeerConnectionInterface::kIceConnectionFailed); | |
| break; | |
| case cricket::kIceConnectionConnected: | |
| RTC_LOG(LS_INFO) << "Changing to ICE connected state because " | |
| "all transports are writable."; | |
| { | |
| std::vector<RtpTransceiverProxyRefPtr> transceivers; | |
| if (ConfiguredForMedia()) { | |
| transceivers = rtp_manager()->transceivers()->List(); | |
| } | |
| network_thread()->PostTask( | |
| SafeTask(network_thread_safety_, | |
| [this, transceivers = std::move(transceivers)] { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| ReportTransportStats(std::move(transceivers)); | |
| })); | |
| } | |
| SetIceConnectionState(PeerConnectionInterface::kIceConnectionConnected); | |
| NoteUsageEvent(UsageEvent::ICE_STATE_CONNECTED); | |
| break; | |
| case cricket::kIceConnectionCompleted: | |
| RTC_LOG(LS_INFO) << "Changing to ICE completed state because " | |
| "all transports are complete."; | |
| if (ice_connection_state_ != | |
| PeerConnectionInterface::kIceConnectionConnected) { | |
| // If jumping directly from "checking" to "connected", | |
| // signal "connected" first. | |
| SetIceConnectionState(PeerConnectionInterface::kIceConnectionConnected); | |
| } | |
| SetIceConnectionState(PeerConnectionInterface::kIceConnectionCompleted); | |
| NoteUsageEvent(UsageEvent::ICE_STATE_CONNECTED); | |
| break; | |
| default: | |
| RTC_DCHECK_NOTREACHED(); | |
| } | |
| } | |
| void PeerConnection::OnTransportControllerCandidatesGathered( | |
| const std::string& transport_name, | |
| const cricket::Candidates& candidates) { | |
| // TODO(bugs.webrtc.org/12427): Expect this to come in on the network thread | |
| // (not signaling as it currently does), handle appropriately. | |
| int sdp_mline_index; | |
| if (!GetLocalCandidateMediaIndex(transport_name, &sdp_mline_index)) { | |
| RTC_LOG(LS_ERROR) | |
| << "OnTransportControllerCandidatesGathered: content name " | |
| << transport_name << " not found"; | |
| return; | |
| } | |
| for (cricket::Candidates::const_iterator citer = candidates.begin(); | |
| citer != candidates.end(); ++citer) { | |
| // Use transport_name as the candidate media id. | |
| std::unique_ptr<JsepIceCandidate> candidate( | |
| new JsepIceCandidate(transport_name, sdp_mline_index, *citer)); | |
| sdp_handler_->AddLocalIceCandidate(candidate.get()); | |
| OnIceCandidate(std::move(candidate)); | |
| } | |
| } | |
| void PeerConnection::OnTransportControllerCandidateError( | |
| const cricket::IceCandidateErrorEvent& event) { | |
| OnIceCandidateError(event.address, event.port, event.url, event.error_code, | |
| event.error_text); | |
| } | |
| void PeerConnection::OnTransportControllerCandidatesRemoved( | |
| const std::vector<cricket::Candidate>& candidates) { | |
| // Sanity check. | |
| for (const cricket::Candidate& candidate : candidates) { | |
| if (candidate.transport_name().empty()) { | |
| RTC_LOG(LS_ERROR) << "OnTransportControllerCandidatesRemoved: " | |
| "empty content name in candidate " | |
| << candidate.ToString(); | |
| return; | |
| } | |
| } | |
| sdp_handler_->RemoveLocalIceCandidates(candidates); | |
| OnIceCandidatesRemoved(candidates); | |
| } | |
| void PeerConnection::OnTransportControllerCandidateChanged( | |
| const cricket::CandidatePairChangeEvent& event) { | |
| OnSelectedCandidatePairChanged(event); | |
| } | |
| void PeerConnection::OnTransportControllerDtlsHandshakeError( | |
| rtc::SSLHandshakeError error) { | |
| RTC_HISTOGRAM_ENUMERATION( | |
| "WebRTC.PeerConnection.DtlsHandshakeError", static_cast<int>(error), | |
| static_cast<int>(rtc::SSLHandshakeError::MAX_VALUE)); | |
| } | |
| // 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) { | |
| if (!local_description() || !sdp_mline_index) { | |
| return false; | |
| } | |
| bool content_found = false; | |
| const ContentInfos& contents = local_description()->description()->contents(); | |
| for (size_t index = 0; index < contents.size(); ++index) { | |
| if (contents[index].name == content_name) { | |
| *sdp_mline_index = static_cast<int>(index); | |
| content_found = true; | |
| break; | |
| } | |
| } | |
| return content_found; | |
| } | |
| Call::Stats PeerConnection::GetCallStats() { | |
| if (!worker_thread()->IsCurrent()) { | |
| return worker_thread()->BlockingCall([this] { return GetCallStats(); }); | |
| } | |
| RTC_DCHECK_RUN_ON(worker_thread()); | |
| rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls; | |
| if (call_) { | |
| return call_->GetStats(); | |
| } else { | |
| return Call::Stats(); | |
| } | |
| } | |
| absl::optional<AudioDeviceModule::Stats> PeerConnection::GetAudioDeviceStats() { | |
| if (context_->media_engine()) { | |
| return context_->media_engine()->voice().GetAudioDeviceStats(); | |
| } | |
| return absl::nullopt; | |
| } | |
| absl::optional<std::string> PeerConnection::SetupDataChannelTransport_n( | |
| absl::string_view mid) { | |
| sctp_mid_n_ = std::string(mid); | |
| DataChannelTransportInterface* transport = | |
| transport_controller_->GetDataChannelTransport(*sctp_mid_n_); | |
| if (!transport) { | |
| RTC_LOG(LS_ERROR) | |
| << "Data channel transport is not available for data channels, mid=" | |
| << mid; | |
| sctp_mid_n_ = absl::nullopt; | |
| return absl::nullopt; | |
| } | |
| absl::optional<std::string> transport_name; | |
| cricket::DtlsTransportInternal* dtls_transport = | |
| transport_controller_->GetDtlsTransport(*sctp_mid_n_); | |
| if (dtls_transport) { | |
| transport_name = dtls_transport->transport_name(); | |
| } else { | |
| // Make sure we still set a valid string. | |
| transport_name = std::string(""); | |
| } | |
| data_channel_controller_.SetupDataChannelTransport_n(transport); | |
| return transport_name; | |
| } | |
| void PeerConnection::TeardownDataChannelTransport_n(RTCError error) { | |
| if (sctp_mid_n_) { | |
| // `sctp_mid_` may still be active through an SCTP transport. If not, unset | |
| // it. | |
| RTC_LOG(LS_INFO) << "Tearing down data channel transport for mid=" | |
| << *sctp_mid_n_; | |
| sctp_mid_n_.reset(); | |
| } | |
| data_channel_controller_.TeardownDataChannelTransport_n(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) { | |
| if (bundle_groups_by_mid.empty()) | |
| return true; | |
| const cricket::ContentInfos& contents = desc->contents(); | |
| for (cricket::ContentInfos::const_iterator citer = contents.begin(); | |
| citer != contents.end(); ++citer) { | |
| const cricket::ContentInfo* content = (&*citer); | |
| RTC_DCHECK(content != NULL); | |
| auto it = bundle_groups_by_mid.find(content->name); | |
| if (it != bundle_groups_by_mid.end() && | |
| !(content->rejected || content->bundle_only) && | |
| content->type == MediaProtocolType::kRtp) { | |
| if (!HasRtcpMuxEnabled(content)) | |
| return false; | |
| } | |
| } | |
| // RTCP-MUX is enabled in all the contents. | |
| return true; | |
| } | |
| void PeerConnection::ReportSdpBundleUsage( | |
| const SessionDescriptionInterface& remote_description) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| bool using_bundle = | |
| remote_description.description()->HasGroup(cricket::GROUP_TYPE_BUNDLE); | |
| int num_audio_mlines = 0; | |
| int num_video_mlines = 0; | |
| int num_data_mlines = 0; | |
| for (const ContentInfo& content : | |
| remote_description.description()->contents()) { | |
| cricket::MediaType media_type = content.media_description()->type(); | |
| if (media_type == cricket::MEDIA_TYPE_AUDIO) { | |
| num_audio_mlines += 1; | |
| } else if (media_type == cricket::MEDIA_TYPE_VIDEO) { | |
| num_video_mlines += 1; | |
| } else if (media_type == cricket::MEDIA_TYPE_DATA) { | |
| num_data_mlines += 1; | |
| } | |
| } | |
| bool simple = num_audio_mlines <= 1 && num_video_mlines <= 1; | |
| BundleUsage usage = kBundleUsageMax; | |
| if (num_audio_mlines == 0 && num_video_mlines == 0) { | |
| if (num_data_mlines > 0) { | |
| usage = using_bundle ? kBundleUsageBundleDatachannelOnly | |
| : kBundleUsageNoBundleDatachannelOnly; | |
| } else { | |
| usage = kBundleUsageEmpty; | |
| } | |
| } else if (configuration_.sdp_semantics == SdpSemantics::kPlanB_DEPRECATED) { | |
| // In plan-b, simple/complex usage will not show up in the number of | |
| // m-lines or BUNDLE. | |
| usage = using_bundle ? kBundleUsageBundlePlanB : kBundleUsageNoBundlePlanB; | |
| } else { | |
| if (simple) { | |
| usage = | |
| using_bundle ? kBundleUsageBundleSimple : kBundleUsageNoBundleSimple; | |
| } else { | |
| usage = using_bundle ? kBundleUsageBundleComplex | |
| : kBundleUsageNoBundleComplex; | |
| } | |
| } | |
| RTC_HISTOGRAM_ENUMERATION("WebRTC.PeerConnection.BundleUsage", usage, | |
| kBundleUsageMax); | |
| } | |
| void PeerConnection::ReportIceCandidateCollected( | |
| const cricket::Candidate& candidate) { | |
| NoteUsageEvent(UsageEvent::CANDIDATE_COLLECTED); | |
| if (candidate.address().IsPrivateIP()) { | |
| NoteUsageEvent(UsageEvent::PRIVATE_CANDIDATE_COLLECTED); | |
| } | |
| if (candidate.address().IsUnresolvedIP()) { | |
| NoteUsageEvent(UsageEvent::MDNS_CANDIDATE_COLLECTED); | |
| } | |
| if (candidate.address().family() == AF_INET6) { | |
| NoteUsageEvent(UsageEvent::IPV6_CANDIDATE_COLLECTED); | |
| } | |
| } | |
| void PeerConnection::NoteUsageEvent(UsageEvent event) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| usage_pattern_.NoteUsageEvent(event); | |
| } | |
| // Asynchronously adds remote candidates on the network thread. | |
| void PeerConnection::AddRemoteCandidate(const std::string& mid, | |
| const cricket::Candidate& candidate) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (candidate.network_type() != rtc::ADAPTER_TYPE_UNKNOWN) { | |
| RTC_DLOG(LS_WARNING) << "Using candidate with adapter type set - this " | |
| "should only happen in test"; | |
| } | |
| // Clear fields that do not make sense as remote candidates. | |
| cricket::Candidate new_candidate(candidate); | |
| new_candidate.set_network_type(rtc::ADAPTER_TYPE_UNKNOWN); | |
| new_candidate.set_relay_protocol(""); | |
| new_candidate.set_underlying_type_for_vpn(rtc::ADAPTER_TYPE_UNKNOWN); | |
| network_thread()->PostTask(SafeTask( | |
| network_thread_safety_, [this, mid = mid, candidate = new_candidate] { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| std::vector<cricket::Candidate> candidates = {candidate}; | |
| RTCError error = | |
| transport_controller_->AddRemoteCandidates(mid, candidates); | |
| if (error.ok()) { | |
| signaling_thread()->PostTask(SafeTask( | |
| signaling_thread_safety_.flag(), | |
| [this, candidate = std::move(candidate)] { | |
| ReportRemoteIceCandidateAdded(candidate); | |
| // Candidates successfully submitted for checking. | |
| if (ice_connection_state() == | |
| PeerConnectionInterface::kIceConnectionNew || | |
| ice_connection_state() == | |
| PeerConnectionInterface::kIceConnectionDisconnected) { | |
| // If state is New, then the session has just gotten its first | |
| // remote ICE candidates, so go to Checking. If state is | |
| // Disconnected, the session is re-using old candidates or | |
| // receiving additional ones, so go to Checking. If state is | |
| // Connected, stay Connected. | |
| // TODO(bemasc): If state is Connected, and the new candidates | |
| // are for a newly added transport, then the state actually | |
| // _should_ move to checking. Add a way to distinguish that | |
| // case. | |
| SetIceConnectionState( | |
| PeerConnectionInterface::kIceConnectionChecking); | |
| } | |
| // TODO(bemasc): If state is Completed, go back to Connected. | |
| })); | |
| } else { | |
| RTC_LOG(LS_WARNING) << error.message(); | |
| } | |
| })); | |
| } | |
| void PeerConnection::ReportUsagePattern() const { | |
| usage_pattern_.ReportUsagePattern(observer_); | |
| } | |
| void PeerConnection::ReportRemoteIceCandidateAdded( | |
| const cricket::Candidate& candidate) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| NoteUsageEvent(UsageEvent::REMOTE_CANDIDATE_ADDED); | |
| if (candidate.address().IsPrivateIP()) { | |
| NoteUsageEvent(UsageEvent::REMOTE_PRIVATE_CANDIDATE_ADDED); | |
| } | |
| if (candidate.address().IsUnresolvedIP()) { | |
| NoteUsageEvent(UsageEvent::REMOTE_MDNS_CANDIDATE_ADDED); | |
| } | |
| if (candidate.address().family() == AF_INET6) { | |
| NoteUsageEvent(UsageEvent::REMOTE_IPV6_CANDIDATE_ADDED); | |
| } | |
| } | |
| bool PeerConnection::SrtpRequired() const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return (dtls_enabled_ || | |
| sdp_handler_->webrtc_session_desc_factory()->SdesPolicy() == | |
| cricket::SEC_REQUIRED); | |
| } | |
| void PeerConnection::OnTransportControllerGatheringState( | |
| cricket::IceGatheringState state) { | |
| RTC_DCHECK(signaling_thread()->IsCurrent()); | |
| if (state == cricket::kIceGatheringGathering) { | |
| OnIceGatheringChange(PeerConnectionInterface::kIceGatheringGathering); | |
| } else if (state == cricket::kIceGatheringComplete) { | |
| OnIceGatheringChange(PeerConnectionInterface::kIceGatheringComplete); | |
| } else if (state == cricket::kIceGatheringNew) { | |
| OnIceGatheringChange(PeerConnectionInterface::kIceGatheringNew); | |
| } else { | |
| RTC_LOG(LS_ERROR) << "Unknown state received: " << state; | |
| RTC_DCHECK_NOTREACHED(); | |
| } | |
| } | |
| // Runs on network_thread(). | |
| void PeerConnection::ReportTransportStats( | |
| std::vector<RtpTransceiverProxyRefPtr> transceivers) { | |
| TRACE_EVENT0("webrtc", "PeerConnection::ReportTransportStats"); | |
| rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls; | |
| std::map<std::string, std::set<cricket::MediaType>> | |
| media_types_by_transport_name; | |
| for (const auto& transceiver : transceivers) { | |
| if (transceiver->internal()->channel()) { | |
| std::string transport_name( | |
| transceiver->internal()->channel()->transport_name()); | |
| media_types_by_transport_name[transport_name].insert( | |
| transceiver->media_type()); | |
| } | |
| } | |
| if (sctp_mid_n_) { | |
| cricket::DtlsTransportInternal* dtls_transport = | |
| transport_controller_->GetDtlsTransport(*sctp_mid_n_); | |
| if (dtls_transport) { | |
| media_types_by_transport_name[dtls_transport->transport_name()].insert( | |
| cricket::MEDIA_TYPE_DATA); | |
| } | |
| } | |
| for (const auto& entry : media_types_by_transport_name) { | |
| const std::string& transport_name = entry.first; | |
| const std::set<cricket::MediaType> media_types = entry.second; | |
| cricket::TransportStats stats; | |
| if (transport_controller_->GetStats(transport_name, &stats)) { | |
| ReportBestConnectionState(stats); | |
| ReportNegotiatedCiphers(dtls_enabled_, stats, media_types); | |
| } | |
| } | |
| } | |
| // 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) { | |
| for (const cricket::TransportChannelStats& channel_stats : | |
| stats.channel_stats) { | |
| for (const cricket::ConnectionInfo& connection_info : | |
| channel_stats.ice_transport_stats.connection_infos) { | |
| if (!connection_info.best_connection) { | |
| continue; | |
| } | |
| const cricket::Candidate& local = connection_info.local_candidate; | |
| const cricket::Candidate& remote = connection_info.remote_candidate; | |
| // Increment the counter for IceCandidatePairType. | |
| if (local.protocol() == cricket::TCP_PROTOCOL_NAME || | |
| (local.type() == RELAY_PORT_TYPE && | |
| local.relay_protocol() == cricket::TCP_PROTOCOL_NAME)) { | |
| RTC_HISTOGRAM_ENUMERATION("WebRTC.PeerConnection.CandidatePairType_TCP", | |
| GetIceCandidatePairCounter(local, remote), | |
| kIceCandidatePairMax); | |
| } else if (local.protocol() == cricket::UDP_PROTOCOL_NAME) { | |
| RTC_HISTOGRAM_ENUMERATION("WebRTC.PeerConnection.CandidatePairType_UDP", | |
| GetIceCandidatePairCounter(local, remote), | |
| kIceCandidatePairMax); | |
| } else { | |
| RTC_CHECK_NOTREACHED(); | |
| } | |
| // Increment the counter for IP type. | |
| if (local.address().family() == AF_INET) { | |
| RTC_HISTOGRAM_ENUMERATION("WebRTC.PeerConnection.IPMetrics", | |
| kBestConnections_IPv4, | |
| kPeerConnectionAddressFamilyCounter_Max); | |
| } else if (local.address().family() == AF_INET6) { | |
| RTC_HISTOGRAM_ENUMERATION("WebRTC.PeerConnection.IPMetrics", | |
| kBestConnections_IPv6, | |
| kPeerConnectionAddressFamilyCounter_Max); | |
| } else { | |
| RTC_CHECK(!local.address().hostname().empty() && | |
| local.address().IsUnresolvedIP()); | |
| } | |
| return; | |
| } | |
| } | |
| } | |
| // static | |
| void PeerConnection::ReportNegotiatedCiphers( | |
| bool dtls_enabled, | |
| const cricket::TransportStats& stats, | |
| const std::set<cricket::MediaType>& media_types) { | |
| if (!dtls_enabled || stats.channel_stats.empty()) { | |
| return; | |
| } | |
| int srtp_crypto_suite = stats.channel_stats[0].srtp_crypto_suite; | |
| int ssl_cipher_suite = stats.channel_stats[0].ssl_cipher_suite; | |
| if (srtp_crypto_suite == rtc::kSrtpInvalidCryptoSuite && | |
| ssl_cipher_suite == rtc::kTlsNullWithNullNull) { | |
| return; | |
| } | |
| if (ssl_cipher_suite != rtc::kTlsNullWithNullNull) { | |
| for (cricket::MediaType media_type : media_types) { | |
| switch (media_type) { | |
| case cricket::MEDIA_TYPE_AUDIO: | |
| RTC_HISTOGRAM_ENUMERATION_SPARSE( | |
| "WebRTC.PeerConnection.SslCipherSuite.Audio", ssl_cipher_suite, | |
| rtc::kSslCipherSuiteMaxValue); | |
| break; | |
| case cricket::MEDIA_TYPE_VIDEO: | |
| RTC_HISTOGRAM_ENUMERATION_SPARSE( | |
| "WebRTC.PeerConnection.SslCipherSuite.Video", ssl_cipher_suite, | |
| rtc::kSslCipherSuiteMaxValue); | |
| break; | |
| case cricket::MEDIA_TYPE_DATA: | |
| RTC_HISTOGRAM_ENUMERATION_SPARSE( | |
| "WebRTC.PeerConnection.SslCipherSuite.Data", ssl_cipher_suite, | |
| rtc::kSslCipherSuiteMaxValue); | |
| break; | |
| default: | |
| RTC_DCHECK_NOTREACHED(); | |
| continue; | |
| } | |
| } | |
| } | |
| uint16_t ssl_peer_signature_algorithm = | |
| stats.channel_stats[0].ssl_peer_signature_algorithm; | |
| if (ssl_peer_signature_algorithm != rtc::kSslSignatureAlgorithmUnknown) { | |
| for (cricket::MediaType media_type : media_types) { | |
| switch (media_type) { | |
| case cricket::MEDIA_TYPE_AUDIO: | |
| RTC_HISTOGRAM_ENUMERATION_SPARSE( | |
| "WebRTC.PeerConnection.SslPeerSignatureAlgorithm.Audio", | |
| ssl_peer_signature_algorithm, | |
| rtc::kSslSignatureAlgorithmMaxValue); | |
| break; | |
| case cricket::MEDIA_TYPE_VIDEO: | |
| RTC_HISTOGRAM_ENUMERATION_SPARSE( | |
| "WebRTC.PeerConnection.SslPeerSignatureAlgorithm.Video", | |
| ssl_peer_signature_algorithm, | |
| rtc::kSslSignatureAlgorithmMaxValue); | |
| break; | |
| case cricket::MEDIA_TYPE_DATA: | |
| RTC_HISTOGRAM_ENUMERATION_SPARSE( | |
| "WebRTC.PeerConnection.SslPeerSignatureAlgorithm.Data", | |
| ssl_peer_signature_algorithm, | |
| rtc::kSslSignatureAlgorithmMaxValue); | |
| break; | |
| default: | |
| RTC_DCHECK_NOTREACHED(); | |
| continue; | |
| } | |
| } | |
| } | |
| } | |
| bool PeerConnection::OnTransportChanged( | |
| const std::string& mid, | |
| RtpTransportInternal* rtp_transport, | |
| rtc::scoped_refptr<DtlsTransport> dtls_transport, | |
| DataChannelTransportInterface* data_channel_transport) { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| bool ret = true; | |
| if (ConfiguredForMedia()) { | |
| for (const auto& transceiver : | |
| rtp_manager()->transceivers()->UnsafeList()) { | |
| cricket::ChannelInterface* channel = transceiver->internal()->channel(); | |
| if (channel && channel->mid() == mid) { | |
| ret = channel->SetRtpTransport(rtp_transport); | |
| } | |
| } | |
| } | |
| if (mid == sctp_mid_n_) { | |
| data_channel_controller_.OnTransportChanged(data_channel_transport); | |
| if (dtls_transport) { | |
| signaling_thread()->PostTask(SafeTask( | |
| signaling_thread_safety_.flag(), | |
| [this, | |
| name = std::string(dtls_transport->internal()->transport_name())] { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| SetSctpTransportName(std::move(name)); | |
| })); | |
| } | |
| } | |
| return ret; | |
| } | |
| PeerConnectionObserver* PeerConnection::Observer() const { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| RTC_DCHECK(observer_); | |
| return observer_; | |
| } | |
| void PeerConnection::StartSctpTransport(int local_port, | |
| int remote_port, | |
| int max_message_size) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (!sctp_mid_s_) | |
| return; | |
| network_thread()->PostTask(SafeTask( | |
| network_thread_safety_, | |
| [this, mid = *sctp_mid_s_, local_port, remote_port, max_message_size] { | |
| rtc::scoped_refptr<SctpTransport> sctp_transport = | |
| transport_controller_n()->GetSctpTransport(mid); | |
| if (sctp_transport) | |
| sctp_transport->Start(local_port, remote_port, max_message_size); | |
| })); | |
| } | |
| CryptoOptions PeerConnection::GetCryptoOptions() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| // TODO(bugs.webrtc.org/9891) - Remove PeerConnectionFactory::CryptoOptions | |
| // after it has been removed. | |
| return configuration_.crypto_options.has_value() | |
| ? *configuration_.crypto_options | |
| : options_.crypto_options; | |
| } | |
| void PeerConnection::ClearStatsCache() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| if (legacy_stats_) { | |
| legacy_stats_->InvalidateCache(); | |
| } | |
| if (stats_collector_) { | |
| stats_collector_->ClearCachedStatsReport(); | |
| } | |
| } | |
| bool PeerConnection::ShouldFireNegotiationNeededEvent(uint32_t event_id) { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| return sdp_handler_->ShouldFireNegotiationNeededEvent(event_id); | |
| } | |
| void PeerConnection::RequestUsagePatternReportForTesting() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| message_handler_.RequestUsagePatternReport( | |
| [this]() { | |
| RTC_DCHECK_RUN_ON(signaling_thread()); | |
| ReportUsagePattern(); | |
| }, | |
| /* delay_ms= */ 0); | |
| } | |
| std::function<void(const rtc::CopyOnWriteBuffer& packet, | |
| int64_t packet_time_us)> | |
| PeerConnection::InitializeRtcpCallback() { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| return [this](const rtc::CopyOnWriteBuffer& packet, | |
| int64_t /*packet_time_us*/) { | |
| worker_thread()->PostTask(SafeTask(worker_thread_safety_, [this, packet]() { | |
| call_ptr_->Receiver()->DeliverRtcpPacket(packet); | |
| })); | |
| }; | |
| } | |
| std::function<void(const RtpPacketReceived& parsed_packet)> | |
| PeerConnection::InitializeUnDemuxablePacketHandler() { | |
| RTC_DCHECK_RUN_ON(network_thread()); | |
| return [this](const RtpPacketReceived& parsed_packet) { | |
| worker_thread()->PostTask( | |
| SafeTask(worker_thread_safety_, [this, parsed_packet]() { | |
| // Deliver the packet anyway to Call to allow Call to do BWE. | |
| // Even if there is no media receiver, the packet has still | |
| // been received on the network and has been correcly parsed. | |
| call_ptr_->Receiver()->DeliverRtpPacket( | |
| MediaType::ANY, parsed_packet, | |
| /*undemuxable_packet_handler=*/ | |
| [](const RtpPacketReceived& packet) { return false; }); | |
| })); | |
| }; | |
| } | |
| } // namespace webrtc |