/* * Copyright 2016 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/rtc_stats_collector.h" #include #include #include #include #include #include #include #include #include #include #include "absl/functional/any_invocable.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_replace.h" #include "api/audio/audio_device.h" #include "api/audio/audio_processing_statistics.h" #include "api/audio_options.h" #include "api/candidate.h" #include "api/data_channel_interface.h" #include "api/dtls_transport_interface.h" #include "api/environment/environment.h" #include "api/make_ref_counted.h" #include "api/media_stream_interface.h" #include "api/media_types.h" #include "api/peer_connection_interface.h" #include "api/rtp_parameters.h" #include "api/rtp_transceiver_direction.h" #include "api/scoped_refptr.h" #include "api/stats/attribute.h" #include "api/stats/rtc_stats.h" #include "api/stats/rtc_stats_collector_callback.h" #include "api/stats/rtc_stats_report.h" #include "api/stats/rtcstats_objects.h" #include "api/task_queue/pending_task_safety_flag.h" #include "api/transport/enums.h" #include "api/units/data_rate.h" #include "api/units/time_delta.h" #include "api/units/timestamp.h" #include "api/video/video_content_type.h" #include "api/video/video_timing.h" #include "api/video_codecs/scalability_mode.h" #include "call/call.h" #include "common_video/include/quality_limitation_reason.h" #include "json/reader.h" #include "json/value.h" #include "media/base/fake_media_engine.h" #include "media/base/media_channel.h" #include "media/base/stream_params.h" #include "modules/rtp_rtcp/include/report_block_data.h" #include "modules/rtp_rtcp/source/rtcp_packet/report_block.h" #include "p2p/base/connection_info.h" #include "p2p/base/ice_transport_internal.h" #include "p2p/base/p2p_constants.h" #include "p2p/base/port.h" #include "p2p/base/transport_description.h" #include "pc/media_stream.h" #include "pc/peer_connection_internal.h" #include "pc/rtp_sender.h" #include "pc/rtp_transceiver.h" #include "pc/scoped_operations_batcher.h" #include "pc/sctp_data_channel.h" #include "pc/stream_collection.h" #include "pc/test/fake_audio_track.h" #include "pc/test/fake_data_channel_controller.h" #include "pc/test/fake_peer_connection_for_stats.h" #include "pc/test/fake_video_track.h" #include "pc/test/fake_video_track_source.h" #include "pc/test/mock_data_channel.h" #include "pc/test/mock_rtp_receiver_internal.h" #include "pc/test/mock_rtp_sender_internal.h" #include "pc/test/rtc_stats_obtainer.h" #include "pc/transport_stats.h" #include "rtc_base/checks.h" #include "rtc_base/event.h" #include "rtc_base/fake_ssl_identity.h" #include "rtc_base/network_constants.h" #include "rtc_base/rtc_certificate.h" #include "rtc_base/socket_address.h" #include "rtc_base/ssl_certificate.h" #include "rtc_base/ssl_fingerprint.h" #include "rtc_base/ssl_identity.h" #include "rtc_base/ssl_stream_adapter.h" #include "rtc_base/synchronization/mutex.h" #include "rtc_base/system/plan_b_only.h" #include "rtc_base/thread.h" #include "rtc_base/time_utils.h" #include "system_wrappers/include/clock.h" #include "test/create_test_environment.h" #include "test/gmock.h" #include "test/gtest.h" #include "test/run_loop.h" #include "test/time_controller/simulated_time_controller.h" using ::testing::_; using ::testing::IsEmpty; using ::testing::Not; using ::testing::NotNull; using ::testing::Return; namespace webrtc { namespace { using RunLoop = test::RunLoop; // Fake data used by `SetupExampleStatsVoiceGraph()` to fill in remote outbound // stats. constexpr Timestamp kRemoteOutboundStatsTimestamp = Timestamp::Millis(123); constexpr Timestamp kRemoteOutboundStatsRemoteTimestamp = Timestamp::Millis(456); constexpr uint32_t kRemoteOutboundStatsPacketsSent = 7u; constexpr uint64_t kRemoteOutboundStatsBytesSent = 8u; constexpr uint64_t kRemoteOutboundStatsReportsCount = 9u; struct CertificateInfo { scoped_refptr certificate; std::vector ders; std::vector pems; std::vector fingerprints; }; // Return the ID for an object of the given type in a report. // The object must be present and be unique. template std::string IdForType(const RTCStatsReport* report) { auto stats_of_my_type = report->RTCStatsReport::GetStatsOfType(); // We cannot use ASSERT here, since we're within a function. EXPECT_EQ(1U, stats_of_my_type.size()) << "Unexpected number of stats of this type"; if (stats_of_my_type.size() == 1) { return stats_of_my_type[0]->id(); } else { // Return something that is not going to be a valid stas ID. return "Type not found"; } } std::unique_ptr CreateFakeCertificateAndInfoFromDers( const std::vector& ders) { RTC_CHECK(!ders.empty()); std::unique_ptr info(new CertificateInfo()); info->ders = ders; for (const std::string& der : ders) { info->pems.push_back(SSLIdentity::DerToPem( "CERTIFICATE", reinterpret_cast(der.c_str()), der.length())); } info->certificate = RTCCertificate::Create( std::unique_ptr(new FakeSSLIdentity(info->pems))); // Strip header/footer and newline characters of PEM strings. for (size_t i = 0; i < info->pems.size(); ++i) { absl::StrReplaceAll({{"-----BEGIN CERTIFICATE-----", ""}, {"-----END CERTIFICATE-----", ""}, {"\n", ""}}, &info->pems[i]); } // Fingerprints for the whole certificate chain, starting with leaf // certificate. const SSLCertChain& chain = info->certificate->GetSSLCertificateChain(); std::unique_ptr fp; for (size_t i = 0; i < chain.GetSize(); i++) { fp = SSLFingerprint::Create("sha-1", chain.Get(i)); EXPECT_TRUE(fp); info->fingerprints.push_back(fp->GetRfc4572Fingerprint()); } EXPECT_EQ(info->ders.size(), info->fingerprints.size()); return info; } std::unique_ptr CreateFakeCandidate( const std::string& hostname, int port, const std::string& protocol, const AdapterType adapter_type, IceCandidateType candidate_type, uint32_t priority, const AdapterType underlying_type_for_vpn = ADAPTER_TYPE_UNKNOWN) { std::unique_ptr candidate(new Candidate( ICE_CANDIDATE_COMPONENT_RTP, protocol, SocketAddress(hostname, port), priority, "iceusernamefragment", "" /* pwd */, candidate_type, 0 /* generation */, "foundationIsAString")); candidate->set_network_type(adapter_type); candidate->set_underlying_type_for_vpn(underlying_type_for_vpn); return candidate; } class MockStatsCollectorCallback : public RTCStatsCollectorCallback { public: MOCK_METHOD(void, OnStatsDelivered, (const scoped_refptr&), (override)); }; // Helper functions to create fake tracks for stats tests. scoped_refptr CreateFakeAudioTrackForStats( const std::string& id, MediaStreamTrackInterface::TrackState state, bool create_fake_audio_processor) { scoped_refptr processor = nullptr; if (create_fake_audio_processor) { processor = make_ref_counted(); processor->stats.apm_statistics.echo_return_loss = 2.0; processor->stats.apm_statistics.echo_return_loss_enhancement = 3.0; } return FakeAudioTrack::Create(id, state, processor); } scoped_refptr CreateFakeVideoTrackForStats( const std::string& id, MediaStreamTrackInterface::TrackState state, scoped_refptr source) { return FakeVideoTrack::Create(id, state, source); } scoped_refptr CreateFakeTrack( MediaType media_type, const std::string& track_id, MediaStreamTrackInterface::TrackState track_state, bool create_fake_audio_processor = false) { if (media_type == MediaType::AUDIO) { return CreateFakeAudioTrackForStats(track_id, track_state, create_fake_audio_processor); } else { RTC_DCHECK_EQ(media_type, MediaType::VIDEO); return CreateFakeVideoTrackForStats(track_id, track_state, nullptr); } } scoped_refptr CreateMockSender( MediaType media_type, scoped_refptr track, uint32_t ssrc, int attachment_id, std::vector local_stream_ids) { RTC_DCHECK(!track || (track->kind() == MediaStreamTrackInterface::kAudioKind && media_type == MediaType::AUDIO) || (track->kind() == MediaStreamTrackInterface::kVideoKind && media_type == MediaType::VIDEO)); auto sender = make_ref_counted(); EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track)); EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc)); EXPECT_CALL(*sender, media_type()).WillRepeatedly(Return(media_type)); EXPECT_CALL(*sender, GetParameters()).WillRepeatedly([s = sender.get()]() { return s->GetParametersInternal(false, false); }); EXPECT_CALL(*sender, GetParametersInternal(_, _)).WillRepeatedly([ssrc]() { RtpParameters params; params.encodings.push_back(RtpEncodingParameters()); params.encodings[0].ssrc = ssrc; return params; }); EXPECT_CALL(*sender, AttachmentId()).WillRepeatedly(Return(attachment_id)); EXPECT_CALL(*sender, stream_ids()).WillRepeatedly(Return(local_stream_ids)); return sender; } scoped_refptr CreateMockReceiver( const scoped_refptr& track, uint32_t ssrc, int attachment_id) { auto receiver = make_ref_counted(); EXPECT_CALL(*receiver, track()).WillRepeatedly(Return(track)); EXPECT_CALL(*receiver, ssrc()).WillRepeatedly([ssrc]() { return ssrc; }); EXPECT_CALL(*receiver, streams()) .WillRepeatedly( Return(std::vector>({}))); EXPECT_CALL(*receiver, media_type()) .WillRepeatedly( Return(track->kind() == MediaStreamTrackInterface::kAudioKind ? MediaType::AUDIO : MediaType::VIDEO)); EXPECT_CALL(*receiver, GetParameters()).WillRepeatedly([ssrc]() { RtpParameters params; params.encodings.push_back(RtpEncodingParameters()); params.encodings[0].ssrc = ssrc; return params; }); EXPECT_CALL(*receiver, AttachmentId()).WillRepeatedly(Return(attachment_id)); EXPECT_CALL(*receiver, Stop()).WillRepeatedly(Return()); return receiver; } class RTCStatsCollectorWrapper { public: explicit RTCStatsCollectorWrapper( scoped_refptr pc, const Environment& env) : pc_(pc), env_(env), stats_collector_(pc_.get(), env) {} RTCStatsCollector& stats_collector() { return stats_collector_; } scoped_refptr GetStatsReport(RunLoop& loop) { scoped_refptr report; stats_collector_.GetStatsReport( RTCStatsObtainer::Create(&report, [&loop] { loop.Quit(); })); loop.Run(); Timestamp after = env_.clock().CurrentTime(); for (const RTCStats& stats : *report) { if (stats.type() == RTCRemoteInboundRtpStreamStats::kType || stats.type() == RTCRemoteOutboundRtpStreamStats::kType) { // Ignore remote timestamps. continue; } EXPECT_LE(stats.timestamp(), after); } return report; } scoped_refptr GetFreshStatsReport(RunLoop& loop) { stats_collector_.ClearCachedStatsReport(); return GetStatsReport(loop); } scoped_refptr SetupLocalTrackAndSender( MediaType media_type, const std::string& track_id, uint32_t ssrc, bool add_stream, int attachment_id) { scoped_refptr local_stream; if (add_stream) { local_stream = MediaStream::Create("LocalStreamId"); pc_->mutable_local_streams()->AddStream(local_stream); } scoped_refptr track; if (media_type == MediaType::AUDIO) { track = CreateFakeTrack(media_type, track_id, MediaStreamTrackInterface::kLive); if (add_stream) { local_stream->AddTrack(scoped_refptr( static_cast(track.get()))); } } else { track = CreateFakeTrack(media_type, track_id, MediaStreamTrackInterface::kLive); if (add_stream) { local_stream->AddTrack(scoped_refptr( static_cast(track.get()))); } } scoped_refptr sender = make_ref_counted(); EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track)); EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc)); EXPECT_CALL(*sender, media_type()).WillRepeatedly([media_type]() { return media_type; }); EXPECT_CALL(*sender, GetParameters()).WillRepeatedly([s = sender.get()]() { return s->GetParametersInternal(false, false); }); EXPECT_CALL(*sender, GetParametersInternal(_, _)).WillRepeatedly([ssrc]() { RtpParameters params; params.encodings.push_back(RtpEncodingParameters()); params.encodings[0].ssrc = ssrc; return params; }); EXPECT_CALL(*sender, AttachmentId()).WillRepeatedly(Return(attachment_id)); EXPECT_CALL(*sender, Stop()).WillRepeatedly(Return()); EXPECT_CALL(*sender, SetSendCodecs(_)).WillRepeatedly(Return()); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); return sender; } scoped_refptr SetupRemoteTrackAndReceiver( MediaType media_type, const std::string& track_id, const std::string& stream_id, uint32_t ssrc) { scoped_refptr remote_stream = MediaStream::Create(stream_id); pc_->mutable_remote_streams()->AddStream(remote_stream); scoped_refptr track; if (media_type == MediaType::AUDIO) { track = CreateFakeTrack(media_type, track_id, MediaStreamTrackInterface::kLive); remote_stream->AddTrack(scoped_refptr( static_cast(track.get()))); } else { track = CreateFakeTrack(media_type, track_id, MediaStreamTrackInterface::kLive); remote_stream->AddTrack(scoped_refptr( static_cast(track.get()))); } scoped_refptr receiver = CreateMockReceiver(track, ssrc, 62); EXPECT_CALL(*receiver, streams()) .WillRepeatedly(Return( std::vector>({remote_stream}))); EXPECT_CALL(*receiver, SetMediaChannel(_)).WillRepeatedly(Return()); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddReceiver(receiver); RTC_ALLOW_PLAN_B_DEPRECATION_END(); return receiver; } // Attaches tracks to peer connections by configuring RTP senders and RTP // receivers according to the tracks' pairings with // |[Voice/Video][Sender/Receiver]Info| and their SSRCs. Local tracks can be // associated with multiple |[Voice/Video]SenderInfo|s, remote tracks can only // be associated with one |[Voice/Video]ReceiverInfo|. // Senders get assigned attachment ID "ssrc + 10". void CreateMockRtpSendersReceiversAndChannels( std::initializer_list< std::pair> local_audio_track_info_pairs, std::initializer_list< std::pair> remote_audio_track_info_pairs, std::initializer_list< std::pair> local_video_track_info_pairs, std::initializer_list< std::pair> remote_video_track_info_pairs, std::vector local_stream_ids, std::vector> remote_streams) { VoiceMediaInfo voice_media_info; VideoMediaInfo video_media_info; // Local audio tracks and voice sender infos for (auto& pair : local_audio_track_info_pairs) { MediaStreamTrackInterface* local_audio_track = pair.first; const VoiceSenderInfo& voice_sender_info = pair.second; RTC_DCHECK_EQ(local_audio_track->kind(), MediaStreamTrackInterface::kAudioKind); voice_media_info.senders.push_back(voice_sender_info); scoped_refptr rtp_sender = CreateMockSender( MediaType::AUDIO, scoped_refptr(local_audio_track), voice_sender_info.local_stats[0].ssrc, voice_sender_info.local_stats[0].ssrc + 10, local_stream_ids); EXPECT_CALL(*rtp_sender, SetMediaChannel(_)).WillRepeatedly(Return()); EXPECT_CALL(*rtp_sender, DetachTrackAndGetStopTask()).WillRepeatedly([] { return nullptr; }); EXPECT_CALL(*rtp_sender, SetSendCodecs(_)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(rtp_sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); } // Remote audio tracks and voice receiver infos for (auto& pair : remote_audio_track_info_pairs) { MediaStreamTrackInterface* remote_audio_track = pair.first; const VoiceReceiverInfo& voice_receiver_info = pair.second; RTC_DCHECK_EQ(remote_audio_track->kind(), MediaStreamTrackInterface::kAudioKind); voice_media_info.receivers.push_back(voice_receiver_info); scoped_refptr rtp_receiver = CreateMockReceiver( scoped_refptr(remote_audio_track), voice_receiver_info.local_stats[0].ssrc, voice_receiver_info.local_stats[0].ssrc + 10); EXPECT_CALL(*rtp_receiver, streams()) .WillRepeatedly(Return(remote_streams)); EXPECT_CALL(*rtp_receiver, SetMediaChannel(_)).WillRepeatedly(Return()); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddReceiver(rtp_receiver); RTC_ALLOW_PLAN_B_DEPRECATION_END(); } // Local video tracks and video sender infos for (auto& pair : local_video_track_info_pairs) { MediaStreamTrackInterface* local_video_track = pair.first; const VideoSenderInfo& video_sender_info = pair.second; RTC_DCHECK_EQ(local_video_track->kind(), MediaStreamTrackInterface::kVideoKind); video_media_info.senders.push_back(video_sender_info); video_media_info.aggregated_senders.push_back(video_sender_info); scoped_refptr rtp_sender = CreateMockSender( MediaType::VIDEO, scoped_refptr(local_video_track), video_sender_info.local_stats[0].ssrc, video_sender_info.local_stats[0].ssrc + 10, local_stream_ids); EXPECT_CALL(*rtp_sender, SetMediaChannel(_)).WillRepeatedly(Return()); EXPECT_CALL(*rtp_sender, DetachTrackAndGetStopTask()).WillRepeatedly([] { return nullptr; }); EXPECT_CALL(*rtp_sender, SetSendCodecs(_)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(rtp_sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); } // Remote video tracks and video receiver infos for (auto& pair : remote_video_track_info_pairs) { MediaStreamTrackInterface* remote_video_track = pair.first; const VideoReceiverInfo& video_receiver_info = pair.second; RTC_DCHECK_EQ(remote_video_track->kind(), MediaStreamTrackInterface::kVideoKind); video_media_info.receivers.push_back(video_receiver_info); scoped_refptr rtp_receiver = CreateMockReceiver( scoped_refptr(remote_video_track), video_receiver_info.local_stats[0].ssrc, video_receiver_info.local_stats[0].ssrc + 10); EXPECT_CALL(*rtp_receiver, streams()) .WillRepeatedly(Return(remote_streams)); EXPECT_CALL(*rtp_receiver, SetMediaChannel(_)).WillRepeatedly(Return()); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddReceiver(rtp_receiver); RTC_ALLOW_PLAN_B_DEPRECATION_END(); } RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("audio", "transport", voice_media_info); pc_->AddVideoChannel("video", "transport", video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); } private: scoped_refptr pc_; const Environment env_; RTCStatsCollector stats_collector_; }; class RTCStatsCollectorTestBase : public ::testing::Test { public: RTCStatsCollectorTestBase() : time_controller_(Timestamp::Zero()), env_(CreateTestEnvironment({.time = time_controller_.GetClock()})), pc_(make_ref_counted(env_)) { data_channel_controller_ = std::make_unique(pc_->network_thread()); } void SetStatsTimestampWithEnvironmentClock(bool enabled) { PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration(); config.set_stats_timestamp_with_environment_clock(enabled); pc_->SetConfiguration(config); // RTCStatsCollector reads this flag in the constructor, so we need to // recreate it. stats_ = std::make_unique(pc_, env_); } void ExpectReportContainsCertificateInfo( const scoped_refptr& report, const CertificateInfo& certinfo) { for (size_t i = 0; i < certinfo.fingerprints.size(); ++i) { RTCCertificateStats expected_certificate_stats( "CF" + certinfo.fingerprints[i], report->timestamp()); expected_certificate_stats.fingerprint = certinfo.fingerprints[i]; expected_certificate_stats.fingerprint_algorithm = "sha-1"; expected_certificate_stats.base64_certificate = certinfo.pems[i]; if (i + 1 < certinfo.fingerprints.size()) { expected_certificate_stats.issuer_certificate_id = "CF" + certinfo.fingerprints[i + 1]; } ASSERT_TRUE(report->Get(expected_certificate_stats.id())); EXPECT_EQ(expected_certificate_stats, report->Get(expected_certificate_stats.id()) ->cast_to()); } } const RTCCertificateStats* GetCertificateStatsFromFingerprint( const scoped_refptr& report, const std::string& fingerprint) { auto certificates = report->GetStatsOfType(); for (const auto* certificate : certificates) { if (*certificate->fingerprint == fingerprint) { return certificate; } } return nullptr; } struct ExampleStatsGraph { scoped_refptr sender; scoped_refptr receiver; scoped_refptr full_report; std::string send_codec_id; std::string recv_codec_id; std::string outbound_rtp_id; std::string inbound_rtp_id; std::string remote_outbound_rtp_id; std::string transport_id; std::string peer_connection_id; std::string media_source_id; }; // Sets up the example stats graph (see ASCII art below) for a video only // call. The graph is used for testing the stats selection algorithm (see // https://w3c.github.io/webrtc-pc/#dfn-stats-selection-algorithm). // These tests test the integration of the stats traversal algorithm inside of // RTCStatsCollector. See rtcstatstraveral_unittest.cc for more stats // traversal tests. ExampleStatsGraph SetupExampleStatsGraphForSelectorTests() { ExampleStatsGraph graph; // codec (send) graph.send_codec_id = "COTTransportName1_1"; VideoMediaInfo video_media_info; RtpCodecParameters send_codec; send_codec.payload_type = 1; send_codec.clock_rate = 0; video_media_info.send_codecs.insert( std::make_pair(send_codec.payload_type, send_codec)); // codec (recv) graph.recv_codec_id = "CITTransportName1_2"; RtpCodecParameters recv_codec; recv_codec.payload_type = 2; recv_codec.clock_rate = 0; video_media_info.receive_codecs.insert( std::make_pair(recv_codec.payload_type, recv_codec)); // outbound-rtp graph.outbound_rtp_id = "OTTransportName1V3"; video_media_info.senders.push_back(VideoSenderInfo()); video_media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); video_media_info.senders[0].local_stats[0].ssrc = 3; video_media_info.senders[0].codec_payload_type = send_codec.payload_type; video_media_info.aggregated_senders.push_back(video_media_info.senders[0]); // inbound-rtp graph.inbound_rtp_id = "ITTransportName1V4"; video_media_info.receivers.push_back(VideoReceiverInfo()); video_media_info.receivers[0].local_stats.push_back(SsrcReceiverInfo()); video_media_info.receivers[0].local_stats[0].ssrc = 4; video_media_info.receivers[0].codec_payload_type = recv_codec.payload_type; video_media_info.receivers[0].packets_received = 123; // transport graph.transport_id = "TTransportName1"; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("VideoMid", "TransportName", video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); // outbound-rtp's sender graph.sender = stats_->SetupLocalTrackAndSender( MediaType::VIDEO, "LocalVideoTrackID", 3, false, 50); // inbound-rtp's receiver graph.receiver = stats_->SetupRemoteTrackAndReceiver( MediaType::VIDEO, "RemoteVideoTrackID", "RemoteStreamId", 4); // peer-connection graph.peer_connection_id = "P"; // media-source (kind: video) graph.media_source_id = "SV" + absl::StrCat(graph.sender->AttachmentId()); // Expected stats graph: // // media-source peer-connection // ^ // | // +--------- outbound-rtp inbound-rtp // | | | | // v v v v // codec (send) transport codec (recv) // Verify the stats graph is set up correctly. graph.full_report = stats_->GetStatsReport(main_thread_); EXPECT_EQ(graph.full_report->size(), 7u); EXPECT_TRUE(graph.full_report->Get(graph.send_codec_id)); EXPECT_TRUE(graph.full_report->Get(graph.recv_codec_id)); EXPECT_TRUE(graph.full_report->Get(graph.outbound_rtp_id)); EXPECT_TRUE(graph.full_report->Get(graph.inbound_rtp_id)); EXPECT_TRUE(graph.full_report->Get(graph.transport_id)); EXPECT_TRUE(graph.full_report->Get(graph.peer_connection_id)); EXPECT_TRUE(graph.full_report->Get(graph.media_source_id)); const auto& outbound_rtp = graph.full_report->Get(graph.outbound_rtp_id) ->cast_to(); EXPECT_EQ(*outbound_rtp.media_source_id, graph.media_source_id); EXPECT_EQ(*outbound_rtp.codec_id, graph.send_codec_id); EXPECT_EQ(*outbound_rtp.transport_id, graph.transport_id); EXPECT_TRUE(graph.full_report->Get(graph.inbound_rtp_id)); // We can't use an ASSERT in a function returning non-void, so just return. if (!graph.full_report->Get(graph.inbound_rtp_id)) { return graph; } const auto& inbound_rtp = graph.full_report->Get(graph.inbound_rtp_id) ->cast_to(); EXPECT_EQ(*inbound_rtp.codec_id, graph.recv_codec_id); EXPECT_EQ(*inbound_rtp.transport_id, graph.transport_id); return graph; } // Sets up an example stats graph (see ASCII art below) for an audio only call // and checks that the expected stats are generated. ExampleStatsGraph SetupExampleStatsVoiceGraph( bool add_remote_outbound_stats) { constexpr uint32_t kLocalSsrc = 3; constexpr uint32_t kRemoteSsrc = 4; ExampleStatsGraph graph; // codec (send) graph.send_codec_id = "COTTransportName1_1"; VoiceMediaInfo media_info; RtpCodecParameters send_codec; send_codec.payload_type = 1; send_codec.clock_rate = 0; media_info.send_codecs.insert( std::make_pair(send_codec.payload_type, send_codec)); // codec (recv) graph.recv_codec_id = "CITTransportName1_2"; RtpCodecParameters recv_codec; recv_codec.payload_type = 2; recv_codec.clock_rate = 0; media_info.receive_codecs.insert( std::make_pair(recv_codec.payload_type, recv_codec)); // outbound-rtp graph.outbound_rtp_id = "OTTransportName1A3"; media_info.senders.push_back(VoiceSenderInfo()); media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); media_info.senders[0].local_stats[0].ssrc = kLocalSsrc; media_info.senders[0].codec_payload_type = send_codec.payload_type; // inbound-rtp graph.inbound_rtp_id = "ITTransportName1A4"; media_info.receivers.push_back(VoiceReceiverInfo()); media_info.receivers[0].local_stats.push_back(SsrcReceiverInfo()); media_info.receivers[0].local_stats[0].ssrc = kRemoteSsrc; media_info.receivers[0].packets_received = 123; media_info.receivers[0].codec_payload_type = recv_codec.payload_type; // remote-outbound-rtp if (add_remote_outbound_stats) { graph.remote_outbound_rtp_id = "ROA4"; media_info.receivers[0].last_sender_report_utc_timestamp = kRemoteOutboundStatsTimestamp; media_info.receivers[0].last_sender_report_timestamp = kRemoteOutboundStatsTimestamp; media_info.receivers[0].last_sender_report_remote_utc_timestamp = kRemoteOutboundStatsRemoteTimestamp; media_info.receivers[0].sender_reports_packets_sent = kRemoteOutboundStatsPacketsSent; media_info.receivers[0].sender_reports_bytes_sent = kRemoteOutboundStatsBytesSent; media_info.receivers[0].sender_reports_reports_count = kRemoteOutboundStatsReportsCount; } // transport graph.transport_id = "TTransportName1"; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("VoiceMid", "TransportName", media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); // outbound-rtp's sender graph.sender = stats_->SetupLocalTrackAndSender( MediaType::AUDIO, "LocalAudioTrackID", kLocalSsrc, false, 50); // inbound-rtp's receiver graph.receiver = stats_->SetupRemoteTrackAndReceiver( MediaType::AUDIO, "RemoteAudioTrackID", "RemoteStreamId", kRemoteSsrc); // peer-connection graph.peer_connection_id = "P"; // media-source (kind: video) graph.media_source_id = "SA" + absl::StrCat(graph.sender->AttachmentId()); // Expected stats graph: // // media-source peer-connection // ^ // | // +--------- outbound-rtp inbound-rtp // | | | | // v v v v // codec (send) transport codec (recv) // Verify the stats graph is set up correctly. graph.full_report = stats_->GetStatsReport(main_thread_); EXPECT_EQ(graph.full_report->size(), add_remote_outbound_stats ? 8u : 7u); EXPECT_TRUE(graph.full_report->Get(graph.send_codec_id)); EXPECT_TRUE(graph.full_report->Get(graph.recv_codec_id)); EXPECT_TRUE(graph.full_report->Get(graph.outbound_rtp_id)); EXPECT_TRUE(graph.full_report->Get(graph.inbound_rtp_id)); EXPECT_TRUE(graph.full_report->Get(graph.transport_id)); EXPECT_TRUE(graph.full_report->Get(graph.peer_connection_id)); EXPECT_TRUE(graph.full_report->Get(graph.media_source_id)); // `graph.remote_outbound_rtp_id` is omitted on purpose so that expectations // can be added by the caller depending on what value it sets for the // `add_remote_outbound_stats` argument. const auto& outbound_rtp = graph.full_report->Get(graph.outbound_rtp_id) ->cast_to(); EXPECT_EQ(*outbound_rtp.media_source_id, graph.media_source_id); EXPECT_EQ(*outbound_rtp.codec_id, graph.send_codec_id); EXPECT_EQ(*outbound_rtp.transport_id, graph.transport_id); EXPECT_TRUE(graph.full_report->Get(graph.inbound_rtp_id)); // We can't use ASSERT in a function with a return value. if (!graph.full_report->Get(graph.inbound_rtp_id)) { return graph; } const auto& inbound_rtp = graph.full_report->Get(graph.inbound_rtp_id) ->cast_to(); EXPECT_EQ(*inbound_rtp.codec_id, graph.recv_codec_id); EXPECT_EQ(*inbound_rtp.transport_id, graph.transport_id); return graph; } protected: GlobalSimulatedTimeController time_controller_; Environment env_; RunLoop main_thread_; scoped_refptr pc_; std::unique_ptr stats_; std::unique_ptr data_channel_controller_; }; class RTCStatsCollectorTest : public RTCStatsCollectorTestBase, public ::testing::WithParamInterface { public: RTCStatsCollectorTest() { SetStatsTimestampWithEnvironmentClock(GetParam()); } }; TEST_P(RTCStatsCollectorTest, SingleCallback) { scoped_refptr result; stats_->stats_collector().GetStatsReport( RTCStatsObtainer::Create(&result, [&] { main_thread_.Quit(); })); main_thread_.Run(); EXPECT_TRUE(result); } TEST_P(RTCStatsCollectorTest, MultipleCallbacks) { scoped_refptr a, b, c; int remaining = 3; auto on_complete = [&] { if (--remaining == 0) main_thread_.Quit(); }; stats_->stats_collector().GetStatsReport( RTCStatsObtainer::Create(&a, on_complete)); stats_->stats_collector().GetStatsReport( RTCStatsObtainer::Create(&b, on_complete)); stats_->stats_collector().GetStatsReport( RTCStatsObtainer::Create(&c, on_complete)); main_thread_.Run(); EXPECT_TRUE(a); EXPECT_TRUE(b); EXPECT_TRUE(c); EXPECT_EQ(a.get(), b.get()); EXPECT_EQ(b.get(), c.get()); } TEST_P(RTCStatsCollectorTest, CachedStatsReports) { // Caching should ensure `a` and `b` are the same report. scoped_refptr a = stats_->GetStatsReport(main_thread_); scoped_refptr b = stats_->GetStatsReport(main_thread_); EXPECT_EQ(a.get(), b.get()); // Invalidate cache by clearing it. stats_->stats_collector().ClearCachedStatsReport(); scoped_refptr c = stats_->GetStatsReport(main_thread_); EXPECT_NE(b.get(), c.get()); // Invalidate cache by advancing time. time_controller_.AdvanceTime(TimeDelta::Millis(51)); scoped_refptr d = stats_->GetStatsReport(main_thread_); EXPECT_TRUE(d); EXPECT_NE(c.get(), d.get()); } TEST_P(RTCStatsCollectorTest, MultipleCallbacksWithInvalidatedCacheInBetween) { scoped_refptr a, b, c; int remaining = 3; auto on_complete = [&] { if (--remaining == 0) main_thread_.Quit(); }; stats_->stats_collector().GetStatsReport( RTCStatsObtainer::Create(&a, on_complete)); stats_->stats_collector().GetStatsReport( RTCStatsObtainer::Create(&b, on_complete)); // Cache is invalidated after 50 ms. main_thread_.Flush(); time_controller_.AdvanceTime(TimeDelta::Millis(51)); stats_->stats_collector().GetStatsReport( RTCStatsObtainer::Create(&c, on_complete)); main_thread_.Run(); EXPECT_TRUE(a); EXPECT_TRUE(b); EXPECT_TRUE(c); EXPECT_EQ(a.get(), b.get()); // The act of doing `AdvanceTime` processes all messages. If this was not the // case we might not require `c` to be fresher than `b`. EXPECT_NE(c.get(), b.get()); } TEST_P(RTCStatsCollectorTest, StatsPreservedWhenChannelClearedConcurrently) { VoiceMediaInfo voice_media_info; voice_media_info.receivers.emplace_back(); voice_media_info.receivers[0].add_ssrc(1); voice_media_info.receivers[0].packets_received = 123; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("AudioMid", "TransportName", voice_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); auto remote_receiver = stats_->SetupRemoteTrackAndReceiver( MediaType::AUDIO, "RemoteAudioTrackID", "RemoteStreamId", 1); auto local_sender = stats_->SetupLocalTrackAndSender( MediaType::AUDIO, "LocalAudioTrackID", 2, /*add_stream=*/true, /*attachment_id=*/2); EXPECT_CALL(*local_sender, SetSendCodecs(_)).WillRepeatedly(Return()); EXPECT_CALL(*local_sender, SetMediaChannel(_)).WillRepeatedly(Return()); EXPECT_CALL(*local_sender, DetachTrackAndGetStopTask()).WillRepeatedly([] { return nullptr; }); EXPECT_CALL(*remote_receiver, SetMediaChannel(_)).WillRepeatedly(Return()); scoped_refptr report; bool stats_obtained = false; stats_->stats_collector().GetStatsReport( RTCStatsObtainer::Create(&report, [&] { stats_obtained = true; main_thread_.Quit(); })); auto transceivers = pc_->GetTransceiversInternal(); ASSERT_FALSE(transceivers.empty()); auto* transceiver = transceivers[0]->internal(); EXPECT_TRUE(transceiver->HasChannel()); auto network_task = transceiver->GetClearChannelNetworkTask(); pc_->network_thread()->BlockingCall([&]() { std::move(network_task)(); }); auto delete_worker_task = transceiver->GetDeleteChannelWorkerTask(/*stop_senders=*/false); // Now the state of the transceiver is that on the signaling thread, // there is no channel. However, the work of actually deleting the channels // belongs to the worker thread task, which hasn't run yet. // Let's post the execution of that task so that it ends up running // *after* the task that the `stats_collector` has queued up for // gathering the stats from the channel. The stats collector should // be able to get the stats safely even though technically the // transceiver by now, doesn't have a channel. EXPECT_FALSE(transceiver->HasChannel()); Event worker_task_done; pc_->worker_thread()->PostTask([&]() { std::move(delete_worker_task)(); worker_task_done.Set(); }); main_thread_.Run(); EXPECT_TRUE(report); auto inbound_rtps = report->GetStatsOfType(); EXPECT_EQ(inbound_rtps.size(), 1u); // Wait for the cleanup task to complete. worker_task_done.Wait(Event::kForever); } TEST_P(RTCStatsCollectorTest, ToJsonProducesParseableJson) { ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests(); scoped_refptr report = stats_->GetStatsReport(main_thread_); std::string json_format = report->ToJson(); Json::CharReaderBuilder builder; Json::Value json_value; std::unique_ptr reader(builder.newCharReader()); ASSERT_TRUE(reader->parse(json_format.c_str(), json_format.c_str() + json_format.size(), &json_value, nullptr)); // A very brief sanity check on the result. EXPECT_EQ(report->size(), json_value.size()); } TEST_P(RTCStatsCollectorTest, ProduceRTPStreamStatsWithStoppedTransceiver) { const char kTransportName[] = "transport"; const char kMid[] = "VideoMid"; VideoMediaInfo video_media_info; video_media_info.senders.emplace_back(); video_media_info.senders[0].add_ssrc(1); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel(kMid, kTransportName, video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); // Get the transceiver and set it to stopped. std::vector>> transceivers = pc_->GetTransceiversInternal(); ASSERT_THAT(transceivers, Not(IsEmpty())); scoped_refptr> transceiver = transceivers[0]; ASSERT_TRUE(transceiver); transceiver->internal()->set_current_direction( RtpTransceiverDirection::kStopped); // This should not crash. scoped_refptr report = stats_->GetStatsReport(main_thread_); EXPECT_THAT(report, NotNull()); } TEST_P(RTCStatsCollectorTest, CollectRTCCertificateStatsSingle) { const char kTransportName[] = "transport"; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("audio", kTransportName); RTC_ALLOW_PLAN_B_DEPRECATION_END(); std::unique_ptr local_certinfo = CreateFakeCertificateAndInfoFromDers( std::vector({"(local) single certificate"})); pc_->SetLocalCertificate(kTransportName, local_certinfo->certificate); std::unique_ptr remote_certinfo = CreateFakeCertificateAndInfoFromDers( std::vector({"(remote) single certificate"})); pc_->SetRemoteCertChain( kTransportName, remote_certinfo->certificate->GetSSLCertificateChain().Clone()); scoped_refptr report = stats_->GetStatsReport(main_thread_); ExpectReportContainsCertificateInfo(report, *local_certinfo); ExpectReportContainsCertificateInfo(report, *remote_certinfo); } // These SSRC collisions are legal. TEST_P(RTCStatsCollectorTest, ValidSsrcCollisionDoesNotCrash) { // BUNDLE audio/video inbound/outbound. Unique SSRCs needed within the BUNDLE. VoiceMediaInfo mid1_info; mid1_info.receivers.emplace_back(); mid1_info.receivers[0].add_ssrc(1); mid1_info.receivers[0].packets_received = 123; mid1_info.senders.emplace_back(); mid1_info.senders[0].add_ssrc(2); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("Mid1", "Transport1", mid1_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); VideoMediaInfo mid2_info; mid2_info.receivers.emplace_back(); mid2_info.receivers[0].add_ssrc(3); mid2_info.receivers[0].packets_received = 123; mid2_info.senders.emplace_back(); mid2_info.senders[0].add_ssrc(4); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("Mid2", "Transport1", mid2_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); // Now create a second BUNDLE group with SSRCs colliding with the first group // (but again no collisions within the group). VoiceMediaInfo mid3_info; mid3_info.receivers.emplace_back(); mid3_info.receivers[0].add_ssrc(1); mid3_info.receivers[0].packets_received = 123; mid3_info.senders.emplace_back(); mid3_info.senders[0].add_ssrc(2); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("Mid3", "Transport2", mid3_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); VideoMediaInfo mid4_info; mid4_info.receivers.emplace_back(); mid4_info.receivers[0].add_ssrc(3); mid4_info.receivers[0].packets_received = 123; mid4_info.senders.emplace_back(); mid4_info.senders[0].add_ssrc(4); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("Mid4", "Transport2", mid4_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); // This should not crash (https://crbug.com/1361612). scoped_refptr report = stats_->GetStatsReport(main_thread_); auto inbound_rtps = report->GetStatsOfType(); auto outbound_rtps = report->GetStatsOfType(); EXPECT_EQ(inbound_rtps.size(), 4u); EXPECT_EQ(outbound_rtps.size(), 4u); } // These SSRC collisions are illegal, so it is not clear if this setup can // happen even when talking to a malicious endpoint, but simulate illegal SSRC // collisions just to make sure we don't crash in even the most extreme cases. TEST_P(RTCStatsCollectorTest, InvalidSsrcCollisionDoesNotCrash) { // One SSRC to rule them all. VoiceMediaInfo mid1_info; mid1_info.receivers.emplace_back(); mid1_info.receivers[0].add_ssrc(1); mid1_info.senders.emplace_back(); mid1_info.senders[0].add_ssrc(1); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("Mid1", "BundledTransport", mid1_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); VideoMediaInfo mid2_info; mid2_info.receivers.emplace_back(); mid2_info.receivers[0].add_ssrc(1); mid2_info.senders.emplace_back(); mid2_info.senders[0].add_ssrc(1); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("Mid2", "BundledTransport", mid2_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); VoiceMediaInfo mid3_info; mid3_info.receivers.emplace_back(); mid3_info.receivers[0].add_ssrc(1); mid3_info.senders.emplace_back(); mid3_info.senders[0].add_ssrc(1); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("Mid3", "BundledTransport", mid3_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); VideoMediaInfo mid4_info; mid4_info.receivers.emplace_back(); mid4_info.receivers[0].add_ssrc(1); mid4_info.senders.emplace_back(); mid4_info.senders[0].add_ssrc(1); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("Mid4", "BundledTransport", mid4_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); // This should not crash (https://crbug.com/1361612). stats_->GetStatsReport(main_thread_); // Because this setup is illegal, there is no "right answer" to how the report // should look. We only care about not crashing. } TEST_P(RTCStatsCollectorTest, CollectRTCCodecStatsOnlyIfReferenced) { // Audio VoiceMediaInfo voice_media_info; RtpCodecParameters inbound_audio_codec; inbound_audio_codec.payload_type = 1; inbound_audio_codec.kind = MediaType::AUDIO; inbound_audio_codec.name = "opus"; inbound_audio_codec.clock_rate = 1337; inbound_audio_codec.num_channels = 1; inbound_audio_codec.parameters = {{"minptime", "10"}, {"useinbandfec", "1"}}; voice_media_info.receive_codecs.insert( std::make_pair(inbound_audio_codec.payload_type, inbound_audio_codec)); RtpCodecParameters outbound_audio_codec; outbound_audio_codec.payload_type = 2; outbound_audio_codec.kind = MediaType::AUDIO; outbound_audio_codec.name = "isac"; outbound_audio_codec.clock_rate = 1338; outbound_audio_codec.num_channels = 2; voice_media_info.send_codecs.insert( std::make_pair(outbound_audio_codec.payload_type, outbound_audio_codec)); // Video VideoMediaInfo video_media_info; RtpCodecParameters inbound_video_codec; inbound_video_codec.payload_type = 3; inbound_video_codec.kind = MediaType::VIDEO; inbound_video_codec.name = "H264"; inbound_video_codec.clock_rate = 1339; inbound_video_codec.parameters = {{"level-asymmetry-allowed", "1"}, {"packetization-mode", "1"}, {"profile-level-id", "42001f"}}; video_media_info.receive_codecs.insert( std::make_pair(inbound_video_codec.payload_type, inbound_video_codec)); RtpCodecParameters outbound_video_codec; outbound_video_codec.payload_type = 4; outbound_video_codec.kind = MediaType::VIDEO; outbound_video_codec.name = "VP8"; outbound_video_codec.clock_rate = 1340; video_media_info.send_codecs.insert( std::make_pair(outbound_video_codec.payload_type, outbound_video_codec)); // Ensure the above codecs are referenced. VoiceReceiverInfo inbound_audio_info; inbound_audio_info.add_ssrc(10); inbound_audio_info.codec_payload_type = 1; inbound_audio_info.packets_received = 123; voice_media_info.receivers.push_back(inbound_audio_info); VoiceSenderInfo outbound_audio_info; outbound_audio_info.add_ssrc(20); outbound_audio_info.codec_payload_type = 2; voice_media_info.senders.push_back(outbound_audio_info); VideoReceiverInfo inbound_video_info; inbound_video_info.add_ssrc(30); inbound_video_info.codec_payload_type = 3; inbound_video_info.packets_received = 123; video_media_info.receivers.push_back(inbound_video_info); VideoSenderInfo outbound_video_info; outbound_video_info.add_ssrc(40); outbound_video_info.codec_payload_type = 4; video_media_info.senders.push_back(outbound_video_info); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); auto audio_channels = pc_->AddVoiceChannel("AudioMid", "TransportName", voice_media_info); auto video_channels = pc_->AddVideoChannel("VideoMid", "TransportName", video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCCodecStats expected_inbound_audio_codec( "CITTransportName1_1_minptime=10;useinbandfec=1", report->timestamp()); expected_inbound_audio_codec.payload_type = 1; expected_inbound_audio_codec.mime_type = "audio/opus"; expected_inbound_audio_codec.clock_rate = 1337; expected_inbound_audio_codec.channels = 1; expected_inbound_audio_codec.sdp_fmtp_line = "minptime=10;useinbandfec=1"; expected_inbound_audio_codec.transport_id = "TTransportName1"; RTCCodecStats expected_outbound_audio_codec("COTTransportName1_2", report->timestamp()); expected_outbound_audio_codec.payload_type = 2; expected_outbound_audio_codec.mime_type = "audio/isac"; expected_outbound_audio_codec.clock_rate = 1338; expected_outbound_audio_codec.channels = 2; expected_outbound_audio_codec.transport_id = "TTransportName1"; RTCCodecStats expected_inbound_video_codec( "CITTransportName1_3_level-asymmetry-allowed=1;" "packetization-mode=1;profile-level-id=42001f", report->timestamp()); expected_inbound_video_codec.payload_type = 3; expected_inbound_video_codec.mime_type = "video/H264"; expected_inbound_video_codec.clock_rate = 1339; expected_inbound_video_codec.sdp_fmtp_line = "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f"; expected_inbound_video_codec.transport_id = "TTransportName1"; RTCCodecStats expected_outbound_video_codec("COTTransportName1_4", report->timestamp()); expected_outbound_video_codec.payload_type = 4; expected_outbound_video_codec.mime_type = "video/VP8"; expected_outbound_video_codec.clock_rate = 1340; expected_outbound_video_codec.transport_id = "TTransportName1"; ASSERT_TRUE(report->Get(expected_inbound_audio_codec.id())); EXPECT_EQ( expected_inbound_audio_codec, report->Get(expected_inbound_audio_codec.id())->cast_to()); ASSERT_TRUE(report->Get(expected_outbound_audio_codec.id())); EXPECT_EQ(expected_outbound_audio_codec, report->Get(expected_outbound_audio_codec.id()) ->cast_to()); ASSERT_TRUE(report->Get(expected_inbound_video_codec.id())); EXPECT_EQ( expected_inbound_video_codec, report->Get(expected_inbound_video_codec.id())->cast_to()); ASSERT_TRUE(report->Get(expected_outbound_video_codec.id())); EXPECT_EQ(expected_outbound_video_codec, report->Get(expected_outbound_video_codec.id()) ->cast_to()); // Now remove all the RTP streams such that there are no live codecId // references to the codecs, this should result in none of the RTCCodecStats // being exposed, despite `send_codecs` and `receive_codecs` still being set. voice_media_info.senders.clear(); voice_media_info.receivers.clear(); audio_channels.first->SetStats(voice_media_info); audio_channels.second->SetStats(voice_media_info); video_media_info.senders.clear(); video_media_info.receivers.clear(); video_channels.first->SetStats(video_media_info); video_channels.second->SetStats(video_media_info); stats_->stats_collector().ClearCachedStatsReport(); report = stats_->GetStatsReport(main_thread_); EXPECT_FALSE(report->Get(expected_inbound_audio_codec.id())); EXPECT_FALSE(report->Get(expected_outbound_audio_codec.id())); EXPECT_FALSE(report->Get(expected_inbound_video_codec.id())); EXPECT_FALSE(report->Get(expected_outbound_video_codec.id())); } TEST_P(RTCStatsCollectorTest, CodecStatsAreCollectedPerTransport) { // PT=10 RtpCodecParameters outbound_codec_pt10; outbound_codec_pt10.payload_type = 10; outbound_codec_pt10.kind = MediaType::VIDEO; outbound_codec_pt10.name = "VP8"; outbound_codec_pt10.clock_rate = 9000; // PT=11 RtpCodecParameters outbound_codec_pt11; outbound_codec_pt11.payload_type = 11; outbound_codec_pt11.kind = MediaType::VIDEO; outbound_codec_pt11.name = "VP8"; outbound_codec_pt11.clock_rate = 9000; // Insert codecs into `send_codecs` and ensure the PTs are referenced by RTP // streams. VideoMediaInfo info_pt10; info_pt10.send_codecs.insert( std::make_pair(outbound_codec_pt10.payload_type, outbound_codec_pt10)); info_pt10.senders.emplace_back(); info_pt10.senders[0].add_ssrc(42); info_pt10.senders[0].codec_payload_type = outbound_codec_pt10.payload_type; VideoMediaInfo info_pt11; info_pt11.send_codecs.insert( std::make_pair(outbound_codec_pt11.payload_type, outbound_codec_pt11)); info_pt11.senders.emplace_back(); info_pt11.senders[0].add_ssrc(43); info_pt11.senders[0].codec_payload_type = outbound_codec_pt11.payload_type; VideoMediaInfo info_pt10_pt11; info_pt10_pt11.send_codecs.insert( std::make_pair(outbound_codec_pt10.payload_type, outbound_codec_pt10)); info_pt10_pt11.send_codecs.insert( std::make_pair(outbound_codec_pt11.payload_type, outbound_codec_pt11)); info_pt10_pt11.senders.emplace_back(); info_pt10_pt11.senders[0].add_ssrc(44); info_pt10_pt11.senders[0].codec_payload_type = outbound_codec_pt10.payload_type; info_pt10_pt11.senders.emplace_back(); info_pt10_pt11.senders[1].add_ssrc(45); info_pt10_pt11.senders[1].codec_payload_type = outbound_codec_pt11.payload_type; // First two mids contain subsets, the third one contains all PTs. RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("Mid1", "FirstTransport", info_pt10); pc_->AddVideoChannel("Mid2", "FirstTransport", info_pt11); pc_->AddVideoChannel("Mid3", "FirstTransport", info_pt10_pt11); RTC_ALLOW_PLAN_B_DEPRECATION_END(); // There should be no duplicate codecs because all codec references are on the // same transport. scoped_refptr report = stats_->GetStatsReport(main_thread_); auto codec_stats = report->GetStatsOfType(); EXPECT_EQ(codec_stats.size(), 2u); // If a second transport is added with the same PT information, this does // count as different codec objects. RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("Mid4", "SecondTransport", info_pt10_pt11); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->stats_collector().ClearCachedStatsReport(); report = stats_->GetStatsReport(main_thread_); codec_stats = report->GetStatsOfType(); EXPECT_EQ(codec_stats.size(), 4u); } TEST_P(RTCStatsCollectorTest, SamePayloadTypeButDifferentFmtpLines) { // PT=111, useinbandfec=0 RtpCodecParameters inbound_codec_pt111_nofec; inbound_codec_pt111_nofec.payload_type = 111; inbound_codec_pt111_nofec.kind = MediaType::AUDIO; inbound_codec_pt111_nofec.name = "opus"; inbound_codec_pt111_nofec.clock_rate = 48000; inbound_codec_pt111_nofec.parameters.insert( std::make_pair("useinbandfec", "0")); // PT=111, useinbandfec=1 RtpCodecParameters inbound_codec_pt111_fec; inbound_codec_pt111_fec.payload_type = 111; inbound_codec_pt111_fec.kind = MediaType::AUDIO; inbound_codec_pt111_fec.name = "opus"; inbound_codec_pt111_fec.clock_rate = 48000; inbound_codec_pt111_fec.parameters.insert( std::make_pair("useinbandfec", "1")); VideoMediaInfo info_nofec; info_nofec.receive_codecs.insert(std::make_pair( inbound_codec_pt111_nofec.payload_type, inbound_codec_pt111_nofec)); info_nofec.receivers.emplace_back(); info_nofec.receivers[0].add_ssrc(123); info_nofec.receivers[0].packets_received = 123; info_nofec.receivers[0].codec_payload_type = inbound_codec_pt111_nofec.payload_type; VideoMediaInfo info_fec; info_fec.receive_codecs.insert(std::make_pair( inbound_codec_pt111_fec.payload_type, inbound_codec_pt111_fec)); info_fec.receivers.emplace_back(); info_fec.receivers[0].add_ssrc(321); info_fec.receivers[0].packets_received = 123; info_fec.receivers[0].codec_payload_type = inbound_codec_pt111_fec.payload_type; // First two mids contain subsets, the third one contains all PTs. RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("Mid1", "BundledTransport", info_nofec); pc_->AddVideoChannel("Mid2", "BundledTransport", info_fec); RTC_ALLOW_PLAN_B_DEPRECATION_END(); // Despite having the same PT we should see two codec stats because their FMTP // lines are different. scoped_refptr report = stats_->GetStatsReport(main_thread_); auto codec_stats = report->GetStatsOfType(); EXPECT_EQ(codec_stats.size(), 2u); // Ensure SSRC uniqueness before the next AddVideoChannel() call. SSRCs need // to be unique on different m= sections when using BUNDLE. info_nofec.receivers[0].local_stats[0].ssrc = 12; info_fec.receivers[0].local_stats[0].ssrc = 21; // Adding more m= sections that does have the same FMTP lines does not result // in duplicates. RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("Mid3", "BundledTransport", info_nofec); pc_->AddVideoChannel("Mid4", "BundledTransport", info_fec); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->stats_collector().ClearCachedStatsReport(); report = stats_->GetStatsReport(main_thread_); codec_stats = report->GetStatsOfType(); EXPECT_EQ(codec_stats.size(), 2u); // Same FMTP line but a different PT does count as a new codec. // PT=112, useinbandfec=1 RtpCodecParameters inbound_codec_pt112_fec; inbound_codec_pt112_fec.payload_type = 112; inbound_codec_pt112_fec.kind = MediaType::AUDIO; inbound_codec_pt112_fec.name = "opus"; inbound_codec_pt112_fec.clock_rate = 48000; inbound_codec_pt112_fec.parameters.insert( std::make_pair("useinbandfec", "1")); VideoMediaInfo info_fec_pt112; info_fec_pt112.receive_codecs.insert(std::make_pair( inbound_codec_pt112_fec.payload_type, inbound_codec_pt112_fec)); info_fec_pt112.receivers.emplace_back(); info_fec_pt112.receivers[0].add_ssrc(112); info_fec_pt112.receivers[0].packets_received = 123; info_fec_pt112.receivers[0].codec_payload_type = inbound_codec_pt112_fec.payload_type; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("Mid5", "BundledTransport", info_fec_pt112); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->stats_collector().ClearCachedStatsReport(); report = stats_->GetStatsReport(main_thread_); codec_stats = report->GetStatsOfType(); EXPECT_EQ(codec_stats.size(), 3u); } TEST_P(RTCStatsCollectorTest, CollectRTCCertificateStatsMultiple) { const char kAudioTransport[] = "audio"; const char kVideoTransport[] = "video"; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("audio", kAudioTransport); RTC_ALLOW_PLAN_B_DEPRECATION_END(); std::unique_ptr audio_local_certinfo = CreateFakeCertificateAndInfoFromDers( std::vector({"(local) audio"})); pc_->SetLocalCertificate(kAudioTransport, audio_local_certinfo->certificate); std::unique_ptr audio_remote_certinfo = CreateFakeCertificateAndInfoFromDers( std::vector({"(remote) audio"})); pc_->SetRemoteCertChain( kAudioTransport, audio_remote_certinfo->certificate->GetSSLCertificateChain().Clone()); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("video", kVideoTransport); RTC_ALLOW_PLAN_B_DEPRECATION_END(); std::unique_ptr video_local_certinfo = CreateFakeCertificateAndInfoFromDers( std::vector({"(local) video"})); pc_->SetLocalCertificate(kVideoTransport, video_local_certinfo->certificate); std::unique_ptr video_remote_certinfo = CreateFakeCertificateAndInfoFromDers( std::vector({"(remote) video"})); pc_->SetRemoteCertChain( kVideoTransport, video_remote_certinfo->certificate->GetSSLCertificateChain().Clone()); scoped_refptr report = stats_->GetStatsReport(main_thread_); ExpectReportContainsCertificateInfo(report, *audio_local_certinfo); ExpectReportContainsCertificateInfo(report, *audio_remote_certinfo); ExpectReportContainsCertificateInfo(report, *video_local_certinfo); ExpectReportContainsCertificateInfo(report, *video_remote_certinfo); } TEST_P(RTCStatsCollectorTest, CollectRTCCertificateStatsChain) { const char kTransportName[] = "transport"; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("audio", kTransportName); RTC_ALLOW_PLAN_B_DEPRECATION_END(); std::unique_ptr local_certinfo = CreateFakeCertificateAndInfoFromDers( {"(local) this", "(local) is", "(local) a", "(local) chain"}); pc_->SetLocalCertificate(kTransportName, local_certinfo->certificate); std::unique_ptr remote_certinfo = CreateFakeCertificateAndInfoFromDers({"(remote) this", "(remote) is", "(remote) another", "(remote) chain"}); pc_->SetRemoteCertChain( kTransportName, remote_certinfo->certificate->GetSSLCertificateChain().Clone()); scoped_refptr report = stats_->GetStatsReport(main_thread_); ExpectReportContainsCertificateInfo(report, *local_certinfo); ExpectReportContainsCertificateInfo(report, *remote_certinfo); } TEST_P(RTCStatsCollectorTest, CertificateStatsCache) { const char kTransportName[] = "transport"; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("audio", kTransportName); RTC_ALLOW_PLAN_B_DEPRECATION_END(); // Set local and remote cerificates. std::unique_ptr initial_local_certinfo = CreateFakeCertificateAndInfoFromDers({"LocalCertA", "LocalCertB"}); pc_->SetLocalCertificate(kTransportName, initial_local_certinfo->certificate); std::unique_ptr initial_remote_certinfo = CreateFakeCertificateAndInfoFromDers({"RemoteCertA", "RemoteCertB"}); pc_->SetRemoteCertChain( kTransportName, initial_remote_certinfo->certificate->GetSSLCertificateChain().Clone()); ASSERT_EQ(initial_local_certinfo->fingerprints.size(), 2u); ASSERT_EQ(initial_remote_certinfo->fingerprints.size(), 2u); scoped_refptr first_report = stats_->GetStatsReport(main_thread_); const auto* first_local_cert0 = GetCertificateStatsFromFingerprint( first_report, initial_local_certinfo->fingerprints[0]); const auto* first_local_cert1 = GetCertificateStatsFromFingerprint( first_report, initial_local_certinfo->fingerprints[1]); const auto* first_remote_cert0 = GetCertificateStatsFromFingerprint( first_report, initial_remote_certinfo->fingerprints[0]); const auto* first_remote_cert1 = GetCertificateStatsFromFingerprint( first_report, initial_remote_certinfo->fingerprints[1]); ASSERT_TRUE(first_local_cert0); ASSERT_TRUE(first_local_cert1); ASSERT_TRUE(first_remote_cert0); ASSERT_TRUE(first_remote_cert1); EXPECT_EQ(first_local_cert0->timestamp(), env_.clock().CurrentTime()); EXPECT_EQ(first_local_cert1->timestamp(), env_.clock().CurrentTime()); EXPECT_EQ(first_remote_cert0->timestamp(), env_.clock().CurrentTime()); EXPECT_EQ(first_remote_cert1->timestamp(), env_.clock().CurrentTime()); // Replace all certificates. std::unique_ptr updated_local_certinfo = CreateFakeCertificateAndInfoFromDers( {"UpdatedLocalCertA", "UpdatedLocalCertB"}); pc_->SetLocalCertificate(kTransportName, updated_local_certinfo->certificate); std::unique_ptr updated_remote_certinfo = CreateFakeCertificateAndInfoFromDers( {"UpdatedRemoteCertA", "UpdatedRemoteCertB"}); pc_->SetRemoteCertChain( kTransportName, updated_remote_certinfo->certificate->GetSSLCertificateChain().Clone()); // This test assumes fingerprints are different for the old and new // certificates. EXPECT_NE(initial_local_certinfo->fingerprints, updated_local_certinfo->fingerprints); EXPECT_NE(initial_remote_certinfo->fingerprints, updated_remote_certinfo->fingerprints); // Advance time to ensure a fresh stats report, but don't clear the // certificate stats cache. time_controller_.AdvanceTime(TimeDelta::Seconds(1)); scoped_refptr second_report = stats_->GetStatsReport(main_thread_); // We expect to see the same certificates as before due to not clearing the // certificate cache. const auto* second_local_cert0 = second_report->GetAs(first_local_cert0->id()); const auto* second_local_cert1 = second_report->GetAs(first_local_cert1->id()); const auto* second_remote_cert0 = second_report->GetAs(first_remote_cert0->id()); const auto* second_remote_cert1 = second_report->GetAs(first_remote_cert1->id()); ASSERT_TRUE(second_local_cert0); ASSERT_TRUE(second_local_cert1); ASSERT_TRUE(second_remote_cert0); ASSERT_TRUE(second_remote_cert1); // The information in the certificate stats are obsolete. EXPECT_EQ(*second_local_cert0->fingerprint, initial_local_certinfo->fingerprints[0]); EXPECT_EQ(*second_local_cert1->fingerprint, initial_local_certinfo->fingerprints[1]); EXPECT_EQ(*second_remote_cert0->fingerprint, initial_remote_certinfo->fingerprints[0]); EXPECT_EQ(*second_remote_cert1->fingerprint, initial_remote_certinfo->fingerprints[1]); // But timestamps are up-to-date, because this is a fresh stats report. EXPECT_EQ(second_local_cert0->timestamp(), env_.clock().CurrentTime()); EXPECT_EQ(second_local_cert1->timestamp(), env_.clock().CurrentTime()); EXPECT_EQ(second_remote_cert0->timestamp(), env_.clock().CurrentTime()); EXPECT_EQ(second_remote_cert1->timestamp(), env_.clock().CurrentTime()); // The updated certificates are not part of the report yet. EXPECT_FALSE(GetCertificateStatsFromFingerprint( second_report, updated_local_certinfo->fingerprints[0])); EXPECT_FALSE(GetCertificateStatsFromFingerprint( second_report, updated_local_certinfo->fingerprints[1])); EXPECT_FALSE(GetCertificateStatsFromFingerprint( second_report, updated_remote_certinfo->fingerprints[0])); EXPECT_FALSE(GetCertificateStatsFromFingerprint( second_report, updated_remote_certinfo->fingerprints[1])); // Clear the cache, including the cached certificates. stats_->stats_collector().ClearCachedStatsReport(); scoped_refptr third_report = stats_->GetStatsReport(main_thread_); // Now the old certificates stats should be deleted. EXPECT_FALSE(third_report->Get(first_local_cert0->id())); EXPECT_FALSE(third_report->Get(first_local_cert1->id())); EXPECT_FALSE(third_report->Get(first_remote_cert0->id())); EXPECT_FALSE(third_report->Get(first_remote_cert1->id())); // And updated certificates exist. EXPECT_TRUE(GetCertificateStatsFromFingerprint( third_report, updated_local_certinfo->fingerprints[0])); EXPECT_TRUE(GetCertificateStatsFromFingerprint( third_report, updated_local_certinfo->fingerprints[1])); EXPECT_TRUE(GetCertificateStatsFromFingerprint( third_report, updated_remote_certinfo->fingerprints[0])); EXPECT_TRUE(GetCertificateStatsFromFingerprint( third_report, updated_remote_certinfo->fingerprints[1])); } TEST_P(RTCStatsCollectorTest, CollectTwoRTCDataChannelStatsWithPendingId) { // Note: The test assumes data channel IDs are predictable. // This is not a safe assumption, but in order to make it work for // the test, we reset the ID allocator at test start. SctpDataChannel::ResetInternalIdAllocatorForTesting(-1); pc_->AddSctpDataChannel(make_ref_counted( data_channel_controller_->weak_ptr(), /*id=*/-1, DataChannelInterface::kConnecting)); pc_->AddSctpDataChannel(make_ref_counted( data_channel_controller_->weak_ptr(), /*id=*/-1, DataChannelInterface::kConnecting)); scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCDataChannelStats expected_data_channel0("D0", Timestamp::Zero()); // Default values from MockDataChannel. expected_data_channel0.label = "MockSctpDataChannel"; expected_data_channel0.protocol = "someProtocol"; expected_data_channel0.state = "connecting"; expected_data_channel0.messages_sent = 0; expected_data_channel0.bytes_sent = 0; expected_data_channel0.messages_received = 0; expected_data_channel0.bytes_received = 0; ASSERT_TRUE(report->Get(expected_data_channel0.id())); EXPECT_EQ( expected_data_channel0, report->Get(expected_data_channel0.id())->cast_to()); } TEST_P(RTCStatsCollectorTest, CollectRTCDataChannelStats) { // Note: The test assumes data channel IDs are predictable. // This is not a safe assumption, but in order to make it work for // the test, we reset the ID allocator at test start. SctpDataChannel::ResetInternalIdAllocatorForTesting(-1); pc_->AddSctpDataChannel(make_ref_counted( data_channel_controller_->weak_ptr(), 0, "MockSctpDataChannel0", DataChannelInterface::kConnecting, "proto1", 1, 2, 3, 4)); RTCDataChannelStats expected_data_channel0("D0", Timestamp::Zero()); expected_data_channel0.label = "MockSctpDataChannel0"; expected_data_channel0.protocol = "proto1"; expected_data_channel0.data_channel_identifier = 0; expected_data_channel0.state = "connecting"; expected_data_channel0.messages_sent = 1; expected_data_channel0.bytes_sent = 2; expected_data_channel0.messages_received = 3; expected_data_channel0.bytes_received = 4; pc_->AddSctpDataChannel(make_ref_counted( data_channel_controller_->weak_ptr(), 1, "MockSctpDataChannel1", DataChannelInterface::kOpen, "proto2", 5, 6, 7, 8)); RTCDataChannelStats expected_data_channel1("D1", Timestamp::Zero()); expected_data_channel1.label = "MockSctpDataChannel1"; expected_data_channel1.protocol = "proto2"; expected_data_channel1.data_channel_identifier = 1; expected_data_channel1.state = "open"; expected_data_channel1.messages_sent = 5; expected_data_channel1.bytes_sent = 6; expected_data_channel1.messages_received = 7; expected_data_channel1.bytes_received = 8; pc_->AddSctpDataChannel(make_ref_counted( data_channel_controller_->weak_ptr(), 2, "MockSctpDataChannel2", DataChannelInterface::kClosing, "proto1", 9, 10, 11, 12)); RTCDataChannelStats expected_data_channel2("D2", Timestamp::Zero()); expected_data_channel2.label = "MockSctpDataChannel2"; expected_data_channel2.protocol = "proto1"; expected_data_channel2.data_channel_identifier = 2; expected_data_channel2.state = "closing"; expected_data_channel2.messages_sent = 9; expected_data_channel2.bytes_sent = 10; expected_data_channel2.messages_received = 11; expected_data_channel2.bytes_received = 12; pc_->AddSctpDataChannel(make_ref_counted( data_channel_controller_->weak_ptr(), 3, "MockSctpDataChannel3", DataChannelInterface::kClosed, "proto3", 13, 14, 15, 16)); RTCDataChannelStats expected_data_channel3("D3", Timestamp::Zero()); expected_data_channel3.label = "MockSctpDataChannel3"; expected_data_channel3.protocol = "proto3"; expected_data_channel3.data_channel_identifier = 3; expected_data_channel3.state = "closed"; expected_data_channel3.messages_sent = 13; expected_data_channel3.bytes_sent = 14; expected_data_channel3.messages_received = 15; expected_data_channel3.bytes_received = 16; scoped_refptr report = stats_->GetStatsReport(main_thread_); ASSERT_TRUE(report->Get(expected_data_channel0.id())); EXPECT_EQ( expected_data_channel0, report->Get(expected_data_channel0.id())->cast_to()); ASSERT_TRUE(report->Get(expected_data_channel1.id())); EXPECT_EQ( expected_data_channel1, report->Get(expected_data_channel1.id())->cast_to()); ASSERT_TRUE(report->Get(expected_data_channel2.id())); EXPECT_EQ( expected_data_channel2, report->Get(expected_data_channel2.id())->cast_to()); ASSERT_TRUE(report->Get(expected_data_channel3.id())); EXPECT_EQ( expected_data_channel3, report->Get(expected_data_channel3.id())->cast_to()); } TEST_P(RTCStatsCollectorTest, CollectRTCIceCandidateStats) { // Candidates in the first transport stats. std::unique_ptr a_local_host = CreateFakeCandidate( "1.2.3.4", 5, "a_local_host's protocol", ADAPTER_TYPE_VPN, IceCandidateType::kHost, 0, ADAPTER_TYPE_ETHERNET); RTCLocalIceCandidateStats expected_a_local_host("I" + a_local_host->id(), Timestamp::Zero()); expected_a_local_host.transport_id = "Ta0"; expected_a_local_host.network_type = "vpn"; expected_a_local_host.ip = "1.2.3.4"; expected_a_local_host.address = "1.2.3.4"; expected_a_local_host.port = 5; expected_a_local_host.protocol = "a_local_host's protocol"; expected_a_local_host.candidate_type = "host"; expected_a_local_host.priority = 0; expected_a_local_host.vpn = true; expected_a_local_host.network_adapter_type = "ethernet"; expected_a_local_host.foundation = "foundationIsAString"; expected_a_local_host.username_fragment = "iceusernamefragment"; std::unique_ptr a_local_tcp_slice = CreateFakeCandidate("1.2.3.4", 5, "tcp", ADAPTER_TYPE_VPN, IceCandidateType::kHost, 0, ADAPTER_TYPE_ETHERNET); a_local_tcp_slice->set_network_slice(NetworkSlice::UNIFIED_COMMUNICATIONS); a_local_tcp_slice->set_tcptype("a_local_tcp_slice's tcptype"); RTCLocalIceCandidateStats expected_a_local_tcp_slice( "I" + a_local_tcp_slice->id(), Timestamp::Zero()); expected_a_local_tcp_slice.transport_id = "Ta0"; expected_a_local_tcp_slice.network_type = "vpn"; expected_a_local_tcp_slice.ip = "1.2.3.4"; expected_a_local_tcp_slice.address = "1.2.3.4"; expected_a_local_tcp_slice.port = 5; expected_a_local_tcp_slice.protocol = "tcp"; expected_a_local_tcp_slice.candidate_type = "host"; expected_a_local_tcp_slice.priority = 0; expected_a_local_tcp_slice.vpn = true; expected_a_local_tcp_slice.network_adapter_type = "ethernet"; expected_a_local_tcp_slice.foundation = "foundationIsAString"; expected_a_local_tcp_slice.username_fragment = "iceusernamefragment"; expected_a_local_tcp_slice.tcp_type = "a_local_tcp_slice's tcptype"; expected_a_local_tcp_slice.network_slice = "unified-communications"; std::unique_ptr a_remote_srflx = CreateFakeCandidate("6.7.8.9", 10, "remote_srflx's protocol", ADAPTER_TYPE_UNKNOWN, IceCandidateType::kSrflx, 1); RTCRemoteIceCandidateStats expected_a_remote_srflx("I" + a_remote_srflx->id(), Timestamp::Zero()); expected_a_remote_srflx.transport_id = "Ta0"; expected_a_remote_srflx.ip = "6.7.8.9"; expected_a_remote_srflx.address = "6.7.8.9"; expected_a_remote_srflx.port = 10; expected_a_remote_srflx.protocol = "remote_srflx's protocol"; expected_a_remote_srflx.candidate_type = "srflx"; expected_a_remote_srflx.priority = 1; expected_a_remote_srflx.foundation = "foundationIsAString"; expected_a_remote_srflx.username_fragment = "iceusernamefragment"; std::unique_ptr a_local_prflx = CreateFakeCandidate( "11.12.13.14", 15, "a_local_prflx's protocol", ADAPTER_TYPE_CELLULAR_2G, IceCandidateType::kPrflx, 2); RTCLocalIceCandidateStats expected_a_local_prflx("I" + a_local_prflx->id(), Timestamp::Zero()); expected_a_local_prflx.transport_id = "Ta0"; expected_a_local_prflx.network_type = "cellular"; expected_a_local_prflx.ip = "11.12.13.14"; expected_a_local_prflx.address = "11.12.13.14"; expected_a_local_prflx.port = 15; expected_a_local_prflx.protocol = "a_local_prflx's protocol"; expected_a_local_prflx.candidate_type = "prflx"; expected_a_local_prflx.priority = 2; expected_a_local_prflx.vpn = false; expected_a_local_prflx.network_adapter_type = "cellular2g"; expected_a_local_prflx.foundation = "foundationIsAString"; expected_a_local_prflx.username_fragment = "iceusernamefragment"; std::unique_ptr a_remote_relay = CreateFakeCandidate("16.17.18.19", 20, "a_remote_relay's protocol", ADAPTER_TYPE_UNKNOWN, IceCandidateType::kRelay, 3); RTCRemoteIceCandidateStats expected_a_remote_relay("I" + a_remote_relay->id(), Timestamp::Zero()); expected_a_remote_relay.transport_id = "Ta0"; expected_a_remote_relay.ip = "16.17.18.19"; expected_a_remote_relay.address = "16.17.18.19"; expected_a_remote_relay.port = 20; expected_a_remote_relay.protocol = "a_remote_relay's protocol"; expected_a_remote_relay.candidate_type = "relay"; expected_a_remote_relay.priority = 3; expected_a_remote_relay.foundation = "foundationIsAString"; expected_a_remote_relay.username_fragment = "iceusernamefragment"; std::unique_ptr a_local_relay = CreateFakeCandidate("16.17.18.19", 21, "a_local_relay's protocol", ADAPTER_TYPE_UNKNOWN, IceCandidateType::kRelay, 1); a_local_relay->set_relay_protocol("tcp"); a_local_relay->set_url("turn:url1"); RTCLocalIceCandidateStats expected_a_local_relay("I" + a_local_relay->id(), Timestamp::Zero()); expected_a_local_relay.transport_id = "Ta0"; expected_a_local_relay.network_type = "unknown"; expected_a_local_relay.ip = "16.17.18.19"; expected_a_local_relay.address = "16.17.18.19"; expected_a_local_relay.port = 21; expected_a_local_relay.protocol = "a_local_relay's protocol"; expected_a_local_relay.relay_protocol = "tcp"; expected_a_local_relay.candidate_type = "relay"; expected_a_local_relay.priority = 1; expected_a_local_relay.url = "turn:url1"; expected_a_local_relay.vpn = false; expected_a_local_relay.network_adapter_type = "unknown"; expected_a_local_relay.foundation = "foundationIsAString"; expected_a_local_relay.username_fragment = "iceusernamefragment"; std::unique_ptr a_local_relay_prflx = CreateFakeCandidate("11.12.13.20", 22, "a_local_relay_prflx's protocol", ADAPTER_TYPE_UNKNOWN, IceCandidateType::kPrflx, 1); a_local_relay_prflx->set_relay_protocol("udp"); RTCLocalIceCandidateStats expected_a_local_relay_prflx( "I" + a_local_relay_prflx->id(), Timestamp::Zero()); expected_a_local_relay_prflx.transport_id = "Ta0"; expected_a_local_relay_prflx.network_type = "unknown"; expected_a_local_relay_prflx.ip = "11.12.13.20"; expected_a_local_relay_prflx.address = "11.12.13.20"; expected_a_local_relay_prflx.port = 22; expected_a_local_relay_prflx.protocol = "a_local_relay_prflx's protocol"; expected_a_local_relay_prflx.relay_protocol = "udp"; expected_a_local_relay_prflx.candidate_type = "prflx"; expected_a_local_relay_prflx.priority = 1; expected_a_local_relay_prflx.vpn = false; expected_a_local_relay_prflx.network_adapter_type = "unknown"; expected_a_local_relay_prflx.foundation = "foundationIsAString"; expected_a_local_relay_prflx.username_fragment = "iceusernamefragment"; // A non-paired local candidate. std::unique_ptr a_local_host_not_paired = CreateFakeCandidate( "1.2.3.4", 4404, "a_local_host_not_paired's protocol", ADAPTER_TYPE_VPN, IceCandidateType::kHost, 0, ADAPTER_TYPE_ETHERNET); RTCLocalIceCandidateStats expected_a_local_host_not_paired( "I" + a_local_host_not_paired->id(), Timestamp::Zero()); expected_a_local_host_not_paired.transport_id = "Ta0"; expected_a_local_host_not_paired.network_type = "vpn"; expected_a_local_host_not_paired.ip = "1.2.3.4"; expected_a_local_host_not_paired.address = "1.2.3.4"; expected_a_local_host_not_paired.port = 4404; expected_a_local_host_not_paired.protocol = "a_local_host_not_paired's protocol"; expected_a_local_host_not_paired.candidate_type = "host"; expected_a_local_host_not_paired.priority = 0; expected_a_local_host_not_paired.vpn = true; expected_a_local_host_not_paired.network_adapter_type = "ethernet"; expected_a_local_host_not_paired.foundation = "foundationIsAString"; expected_a_local_host_not_paired.username_fragment = "iceusernamefragment"; // Candidates in the second transport stats. std::unique_ptr b_local = CreateFakeCandidate("42.42.42.42", 42, "b_local's protocol", ADAPTER_TYPE_WIFI, IceCandidateType::kHost, 42); RTCLocalIceCandidateStats expected_b_local("I" + b_local->id(), Timestamp::Zero()); expected_b_local.transport_id = "Tb0"; expected_b_local.network_type = "wifi"; expected_b_local.ip = "42.42.42.42"; expected_b_local.address = "42.42.42.42"; expected_b_local.port = 42; expected_b_local.protocol = "b_local's protocol"; expected_b_local.candidate_type = "host"; expected_b_local.priority = 42; expected_b_local.vpn = false; expected_b_local.network_adapter_type = "wifi"; expected_b_local.foundation = "foundationIsAString"; expected_b_local.username_fragment = "iceusernamefragment"; std::unique_ptr b_remote = CreateFakeCandidate("42.42.42.42", 42, "b_remote's protocol", ADAPTER_TYPE_UNKNOWN, IceCandidateType::kHost, 42); RTCRemoteIceCandidateStats expected_b_remote("I" + b_remote->id(), Timestamp::Zero()); expected_b_remote.transport_id = "Tb0"; expected_b_remote.ip = "42.42.42.42"; expected_b_remote.address = "42.42.42.42"; expected_b_remote.port = 42; expected_b_remote.protocol = "b_remote's protocol"; expected_b_remote.candidate_type = "host"; expected_b_remote.priority = 42; expected_b_remote.foundation = "foundationIsAString"; expected_b_remote.username_fragment = "iceusernamefragment"; // Add candidate pairs to connection. TransportChannelStats a_transport_channel_stats; a_transport_channel_stats.ice_transport_stats.connection_infos.push_back( ConnectionInfo()); a_transport_channel_stats.ice_transport_stats.connection_infos[0] .local_candidate = *a_local_host; a_transport_channel_stats.ice_transport_stats.connection_infos[0] .remote_candidate = *a_remote_srflx; a_transport_channel_stats.ice_transport_stats.connection_infos.push_back( ConnectionInfo()); a_transport_channel_stats.ice_transport_stats.connection_infos[1] .local_candidate = *a_local_prflx; a_transport_channel_stats.ice_transport_stats.connection_infos[1] .remote_candidate = *a_remote_relay; a_transport_channel_stats.ice_transport_stats.connection_infos.push_back( ConnectionInfo()); a_transport_channel_stats.ice_transport_stats.connection_infos[2] .local_candidate = *a_local_relay; a_transport_channel_stats.ice_transport_stats.connection_infos[2] .remote_candidate = *a_remote_relay; a_transport_channel_stats.ice_transport_stats.connection_infos.push_back( ConnectionInfo()); a_transport_channel_stats.ice_transport_stats.connection_infos[3] .local_candidate = *a_local_relay_prflx; a_transport_channel_stats.ice_transport_stats.connection_infos[3] .remote_candidate = *a_remote_relay; a_transport_channel_stats.ice_transport_stats.candidate_stats_list.push_back( CandidateStats(*a_local_host_not_paired)); a_transport_channel_stats.ice_transport_stats.candidate_stats_list.push_back( CandidateStats(*a_local_tcp_slice)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("audio", "a"); RTC_ALLOW_PLAN_B_DEPRECATION_END(); pc_->SetTransportStats("a", a_transport_channel_stats); TransportChannelStats b_transport_channel_stats; b_transport_channel_stats.ice_transport_stats.connection_infos.push_back( ConnectionInfo()); b_transport_channel_stats.ice_transport_stats.connection_infos[0] .local_candidate = *b_local; b_transport_channel_stats.ice_transport_stats.connection_infos[0] .remote_candidate = *b_remote; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("video", "b"); RTC_ALLOW_PLAN_B_DEPRECATION_END(); pc_->SetTransportStats("b", b_transport_channel_stats); scoped_refptr report = stats_->GetStatsReport(main_thread_); ASSERT_TRUE(report->Get(expected_a_local_host.id())); EXPECT_EQ(expected_a_local_host, report->Get(expected_a_local_host.id()) ->cast_to()); ASSERT_TRUE(report->Get(expected_a_local_tcp_slice.id())); EXPECT_EQ(expected_a_local_tcp_slice, report->Get(expected_a_local_tcp_slice.id()) ->cast_to()); ASSERT_TRUE(report->Get(expected_a_local_host_not_paired.id())); EXPECT_EQ(expected_a_local_host_not_paired, report->Get(expected_a_local_host_not_paired.id()) ->cast_to()); ASSERT_TRUE(report->Get(expected_a_remote_srflx.id())); EXPECT_EQ(expected_a_remote_srflx, report->Get(expected_a_remote_srflx.id()) ->cast_to()); ASSERT_TRUE(report->Get(expected_a_local_prflx.id())); EXPECT_EQ(expected_a_local_prflx, report->Get(expected_a_local_prflx.id()) ->cast_to()); ASSERT_TRUE(report->Get(expected_a_remote_relay.id())); EXPECT_EQ(expected_a_remote_relay, report->Get(expected_a_remote_relay.id()) ->cast_to()); ASSERT_TRUE(report->Get(expected_a_local_relay.id())); EXPECT_EQ(expected_a_local_relay, report->Get(expected_a_local_relay.id()) ->cast_to()); ASSERT_TRUE(report->Get(expected_a_local_relay_prflx.id())); EXPECT_EQ(expected_a_local_relay_prflx, report->Get(expected_a_local_relay_prflx.id()) ->cast_to()); ASSERT_TRUE(report->Get(expected_b_local.id())); EXPECT_EQ( expected_b_local, report->Get(expected_b_local.id())->cast_to()); ASSERT_TRUE(report->Get(expected_b_remote.id())); EXPECT_EQ(expected_b_remote, report->Get(expected_b_remote.id()) ->cast_to()); EXPECT_TRUE(report->Get("Ta0")); EXPECT_TRUE(report->Get("Tb0")); } TEST_P(RTCStatsCollectorTest, CollectRTCIceCandidatePairStats) { const char kTransportName[] = "transport"; std::unique_ptr local_candidate = CreateFakeCandidate("42.42.42.42", 42, "protocol", ADAPTER_TYPE_WIFI, IceCandidateType::kHost, 42); local_candidate->set_username("local_iceusernamefragment"); std::unique_ptr remote_candidate = CreateFakeCandidate("42.42.42.42", 42, "protocol", ADAPTER_TYPE_UNKNOWN, IceCandidateType::kSrflx, 42); remote_candidate->set_related_address(SocketAddress("192.168.2.1", 43)); remote_candidate->set_username("remote_iceusernamefragment"); ConnectionInfo connection_info; connection_info.best_connection = false; connection_info.local_candidate = *local_candidate; connection_info.remote_candidate = *remote_candidate; connection_info.writable = true; connection_info.sent_discarded_packets = 3; connection_info.sent_total_packets = 10; connection_info.packets_received = 51; connection_info.sent_discarded_bytes = 7; connection_info.sent_total_bytes = 42; connection_info.recv_total_bytes = 1234; connection_info.total_round_trip_time_ms = 0; connection_info.current_round_trip_time_ms = std::nullopt; connection_info.recv_ping_requests = 2020; connection_info.sent_ping_requests_total = 2222; connection_info.sent_ping_requests_before_first_response = 2000; connection_info.recv_ping_responses = 4321; connection_info.sent_ping_responses = 1000; connection_info.state = IceCandidatePairState::IN_PROGRESS; connection_info.priority = 5555; connection_info.nominated = false; connection_info.last_data_received = Timestamp::Millis(2500); connection_info.last_data_sent = Timestamp::Millis(5200); TransportChannelStats transport_channel_stats; transport_channel_stats.component = ICE_CANDIDATE_COMPONENT_RTP; transport_channel_stats.ice_transport_stats.connection_infos.push_back( connection_info); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("video", kTransportName); RTC_ALLOW_PLAN_B_DEPRECATION_END(); pc_->SetTransportStats(kTransportName, transport_channel_stats); scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCIceCandidatePairStats expected_pair( "CP" + local_candidate->id() + "_" + remote_candidate->id(), report->timestamp()); expected_pair.transport_id = "Ttransport" + absl::StrCat(ICE_CANDIDATE_COMPONENT_RTP); expected_pair.local_candidate_id = "I" + local_candidate->id(); expected_pair.remote_candidate_id = "I" + remote_candidate->id(); expected_pair.state = "in-progress"; expected_pair.priority = 5555; expected_pair.nominated = false; expected_pair.writable = true; expected_pair.packets_sent = 7; expected_pair.packets_received = 51; expected_pair.packets_discarded_on_send = 3; expected_pair.bytes_sent = 42; expected_pair.bytes_received = 1234; expected_pair.bytes_discarded_on_send = 7; expected_pair.total_round_trip_time = 0.0; expected_pair.requests_received = 2020; expected_pair.requests_sent = 2222; expected_pair.responses_received = 4321; expected_pair.responses_sent = 1000; expected_pair.consent_requests_sent = (2222 - 2000); expected_pair.last_packet_received_timestamp = 2500; expected_pair.last_packet_sent_timestamp = 5200; // `expected_pair.current_round_trip_time` should be undefined because the // current RTT is not set. // `expected_pair.available_[outgoing/incoming]_bitrate` should be undefined // because is is not the current pair. ASSERT_TRUE(report->Get(expected_pair.id())); EXPECT_EQ( expected_pair, report->Get(expected_pair.id())->cast_to()); EXPECT_TRUE(report->Get(*expected_pair.transport_id)); // Set nominated and "GetStats" again. transport_channel_stats.ice_transport_stats.connection_infos[0].nominated = true; pc_->SetTransportStats(kTransportName, transport_channel_stats); report = stats_->GetFreshStatsReport(main_thread_); expected_pair.nominated = true; ASSERT_TRUE(report->Get(expected_pair.id())); EXPECT_EQ( expected_pair, report->Get(expected_pair.id())->cast_to()); EXPECT_TRUE(report->Get(*expected_pair.transport_id)); // Set round trip times and "GetStats" again. transport_channel_stats.ice_transport_stats.connection_infos[0] .total_round_trip_time_ms = 7331; transport_channel_stats.ice_transport_stats.connection_infos[0] .current_round_trip_time_ms = 1337; pc_->SetTransportStats(kTransportName, transport_channel_stats); report = stats_->GetFreshStatsReport(main_thread_); expected_pair.total_round_trip_time = 7.331; expected_pair.current_round_trip_time = 1.337; ASSERT_TRUE(report->Get(expected_pair.id())); EXPECT_EQ( expected_pair, report->Get(expected_pair.id())->cast_to()); EXPECT_TRUE(report->Get(*expected_pair.transport_id)); // Make pair the current pair, clear bandwidth and "GetStats" again. transport_channel_stats.ice_transport_stats.connection_infos[0] .best_connection = true; pc_->SetTransportStats(kTransportName, transport_channel_stats); report = stats_->GetFreshStatsReport(main_thread_); // |expected_pair.available_[outgoing/incoming]_bitrate| should still be // undefined because bandwidth is not set. ASSERT_TRUE(report->Get(expected_pair.id())); EXPECT_EQ( expected_pair, report->Get(expected_pair.id())->cast_to()); EXPECT_TRUE(report->Get(*expected_pair.transport_id)); // Set bandwidth and "GetStats" again. Call::Stats call_stats; const int kSendBandwidth = 888; call_stats.send_bandwidth_bps = kSendBandwidth; const int kRecvBandwidth = 999; call_stats.recv_bandwidth_bps = kRecvBandwidth; pc_->SetCallStats(call_stats); report = stats_->GetFreshStatsReport(main_thread_); expected_pair.available_outgoing_bitrate = kSendBandwidth; expected_pair.available_incoming_bitrate = kRecvBandwidth; ASSERT_TRUE(report->Get(expected_pair.id())); EXPECT_EQ( expected_pair, report->Get(expected_pair.id())->cast_to()); EXPECT_TRUE(report->Get(*expected_pair.transport_id)); RTCLocalIceCandidateStats expected_local_candidate( *expected_pair.local_candidate_id, report->timestamp()); expected_local_candidate.transport_id = *expected_pair.transport_id; expected_local_candidate.network_type = "wifi"; expected_local_candidate.ip = "42.42.42.42"; expected_local_candidate.address = "42.42.42.42"; expected_local_candidate.port = 42; expected_local_candidate.protocol = "protocol"; expected_local_candidate.candidate_type = "host"; expected_local_candidate.priority = 42; expected_local_candidate.foundation = "foundationIsAString"; expected_local_candidate.username_fragment = "local_iceusernamefragment"; expected_local_candidate.vpn = false; expected_local_candidate.network_adapter_type = "wifi"; ASSERT_TRUE(report->Get(expected_local_candidate.id())); EXPECT_EQ(expected_local_candidate, report->Get(expected_local_candidate.id()) ->cast_to()); RTCRemoteIceCandidateStats expected_remote_candidate( *expected_pair.remote_candidate_id, report->timestamp()); expected_remote_candidate.transport_id = *expected_pair.transport_id; expected_remote_candidate.ip = "42.42.42.42"; expected_remote_candidate.address = "42.42.42.42"; expected_remote_candidate.port = 42; expected_remote_candidate.protocol = "protocol"; expected_remote_candidate.candidate_type = "srflx"; expected_remote_candidate.priority = 42; expected_remote_candidate.foundation = "foundationIsAString"; expected_remote_candidate.username_fragment = "remote_iceusernamefragment"; expected_remote_candidate.related_address = "192.168.2.1"; expected_remote_candidate.related_port = 43; ASSERT_TRUE(report->Get(expected_remote_candidate.id())); EXPECT_EQ(expected_remote_candidate, report->Get(expected_remote_candidate.id()) ->cast_to()); } TEST_P(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) { { scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCPeerConnectionStats expected("P", report->timestamp()); expected.data_channels_opened = 0; expected.data_channels_closed = 0; ASSERT_TRUE(report->Get("P")); EXPECT_EQ(expected, report->Get("P")->cast_to()); } ScopedTaskSafety signaling_safety; FakeDataChannelController controller(pc_->network_thread()); scoped_refptr dummy_channel_a = SctpDataChannel::Create( controller.weak_ptr(), "DummyChannelA", false, InternalDataChannelInit(), std::nullopt, signaling_safety.flag(), Thread::Current(), Thread::Current()); scoped_refptr dummy_channel_b = SctpDataChannel::Create( controller.weak_ptr(), "DummyChannelB", false, InternalDataChannelInit(), std::nullopt, signaling_safety.flag(), Thread::Current(), Thread::Current()); stats_->stats_collector().OnSctpDataChannelStateChanged( dummy_channel_a->internal_id(), DataChannelInterface::DataState::kOpen); // Closing a channel that is not opened should not affect the counts. stats_->stats_collector().OnSctpDataChannelStateChanged( dummy_channel_b->internal_id(), DataChannelInterface::DataState::kClosed); { scoped_refptr report = stats_->GetFreshStatsReport(main_thread_); RTCPeerConnectionStats expected("P", report->timestamp()); expected.data_channels_opened = 1; expected.data_channels_closed = 0; ASSERT_TRUE(report->Get("P")); EXPECT_EQ(expected, report->Get("P")->cast_to()); } stats_->stats_collector().OnSctpDataChannelStateChanged( dummy_channel_b->internal_id(), DataChannelInterface::DataState::kOpen); stats_->stats_collector().OnSctpDataChannelStateChanged( dummy_channel_b->internal_id(), DataChannelInterface::DataState::kClosed); { scoped_refptr report = stats_->GetFreshStatsReport(main_thread_); RTCPeerConnectionStats expected("P", report->timestamp()); expected.data_channels_opened = 2; expected.data_channels_closed = 1; ASSERT_TRUE(report->Get("P")); EXPECT_EQ(expected, report->Get("P")->cast_to()); } // Re-opening a data channel (or opening a new data channel that is re-using // the same address in memory) should increase the opened count. stats_->stats_collector().OnSctpDataChannelStateChanged( dummy_channel_b->internal_id(), DataChannelInterface::DataState::kOpen); { scoped_refptr report = stats_->GetFreshStatsReport(main_thread_); RTCPeerConnectionStats expected("P", report->timestamp()); expected.data_channels_opened = 3; expected.data_channels_closed = 1; ASSERT_TRUE(report->Get("P")); EXPECT_EQ(expected, report->Get("P")->cast_to()); } stats_->stats_collector().OnSctpDataChannelStateChanged( dummy_channel_a->internal_id(), DataChannelInterface::DataState::kClosed); stats_->stats_collector().OnSctpDataChannelStateChanged( dummy_channel_b->internal_id(), DataChannelInterface::DataState::kClosed); { scoped_refptr report = stats_->GetFreshStatsReport(main_thread_); RTCPeerConnectionStats expected("P", report->timestamp()); expected.data_channels_opened = 3; expected.data_channels_closed = 3; ASSERT_TRUE(report->Get("P")); EXPECT_EQ(expected, report->Get("P")->cast_to()); } } TEST_P(RTCStatsCollectorTest, CollectRTCInboundRtpStreamStats_Audio) { VoiceMediaInfo voice_media_info; voice_media_info.receivers.push_back(VoiceReceiverInfo()); voice_media_info.receivers[0].local_stats.push_back(SsrcReceiverInfo()); voice_media_info.receivers[0].local_stats[0].ssrc = 1; voice_media_info.receivers[0].packets_lost = -1; // Signed per RFC3550 voice_media_info.receivers[0].packets_discarded = 7788; voice_media_info.receivers[0].packets_received = 2; voice_media_info.receivers[0].packets_received_with_ect1 = 7; voice_media_info.receivers[0].packets_received_with_ce = 5; voice_media_info.receivers[0].nacks_sent = 5; voice_media_info.receivers[0].fec_packets_discarded = 5566; voice_media_info.receivers[0].fec_packets_received = 6677; voice_media_info.receivers[0].payload_bytes_received = 3; voice_media_info.receivers[0].header_and_padding_bytes_received = 4; voice_media_info.receivers[0].codec_payload_type = 42; voice_media_info.receivers[0].jitter_ms = 4500; voice_media_info.receivers[0].jitter_buffer_delay_seconds = 1.0; voice_media_info.receivers[0].jitter_buffer_target_delay_seconds = 1.1; voice_media_info.receivers[0].jitter_buffer_minimum_delay_seconds = 0.999; voice_media_info.receivers[0].jitter_buffer_emitted_count = 2; voice_media_info.receivers[0].total_samples_received = 3; voice_media_info.receivers[0].concealed_samples = 4; voice_media_info.receivers[0].silent_concealed_samples = 5; voice_media_info.receivers[0].concealment_events = 6; voice_media_info.receivers[0].inserted_samples_for_deceleration = 7; voice_media_info.receivers[0].removed_samples_for_acceleration = 8; voice_media_info.receivers[0].audio_level = 14442; // [0,32767] voice_media_info.receivers[0].total_output_energy = 10.0; voice_media_info.receivers[0].total_output_duration = 11.0; voice_media_info.receivers[0].jitter_buffer_flushes = 7; voice_media_info.receivers[0].delayed_packet_outage_samples = 15; voice_media_info.receivers[0].relative_packet_arrival_delay_seconds = 16; voice_media_info.receivers[0].interruption_count = 7788; voice_media_info.receivers[0].total_interruption_duration_ms = 778899; voice_media_info.receivers[0].last_packet_received = std::nullopt; voice_media_info.receivers[0].total_processing_delay_seconds = 0.123; RtpCodecParameters codec_parameters; codec_parameters.payload_type = 42; codec_parameters.kind = MediaType::AUDIO; codec_parameters.name = "dummy"; codec_parameters.clock_rate = 0; voice_media_info.receive_codecs.insert( std::make_pair(codec_parameters.payload_type, codec_parameters)); Call::Stats call_stats; call_stats.sent_ccfb_stats_per_ssrc[1] = { .num_packets_reported_lost = 222, .num_packets_reported_recovered = 200}; pc_->SetCallStats(call_stats); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); auto voice_media_channels = pc_->AddVoiceChannel("AudioMid", "TransportName", voice_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->SetupRemoteTrackAndReceiver(MediaType::AUDIO, "RemoteAudioTrackID", "RemoteStreamId", 1); // Needed for playoutId to be populated. pc_->SetAudioDeviceStats(AudioDeviceModule::Stats()); pc_->GetTransceiversInternal()[0]->internal()->set_current_direction( RtpTransceiverDirection::kSendRecv); scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCInboundRtpStreamStats expected_audio("ITTransportName1A1", report->timestamp()); expected_audio.ssrc = 1; expected_audio.kind = "audio"; expected_audio.track_identifier = "RemoteAudioTrackID"; expected_audio.mid = "AudioMid"; expected_audio.transport_id = "TTransportName1"; expected_audio.codec_id = "CITTransportName1_42"; expected_audio.packets_received = 2; expected_audio.packets_received_with_ect1 = 7; expected_audio.packets_received_with_ce = 5; expected_audio.packets_reported_as_lost = 222; expected_audio.packets_reported_as_lost_but_recovered = 200; expected_audio.nack_count = 5; expected_audio.fec_packets_discarded = 5566; expected_audio.fec_packets_received = 6677; expected_audio.bytes_received = 3; expected_audio.header_bytes_received = 4; expected_audio.packets_lost = -1; expected_audio.packets_discarded = 7788; // `expected_audio.last_packet_received_timestamp` should be undefined. expected_audio.jitter = 4.5; expected_audio.jitter_buffer_delay = 1.0; expected_audio.jitter_buffer_target_delay = 1.1; expected_audio.jitter_buffer_minimum_delay = 0.999; expected_audio.jitter_buffer_emitted_count = 2; expected_audio.total_samples_received = 3; expected_audio.concealed_samples = 4; expected_audio.silent_concealed_samples = 5; expected_audio.concealment_events = 6; expected_audio.inserted_samples_for_deceleration = 7; expected_audio.removed_samples_for_acceleration = 8; expected_audio.audio_level = 14442.0 / 32767.0; // [0,1] expected_audio.total_audio_energy = 10.0; expected_audio.total_samples_duration = 11.0; expected_audio.jitter_buffer_flushes = 7; expected_audio.delayed_packet_outage_samples = 15; expected_audio.relative_packet_arrival_delay = 16; expected_audio.interruption_count = 7788; expected_audio.total_interruption_duration = 778.899; expected_audio.total_processing_delay = 0.123; expected_audio.playout_id = "AP"; ASSERT_TRUE(report->Get(expected_audio.id())); EXPECT_EQ( report->Get(expected_audio.id())->cast_to(), expected_audio); // Set previously undefined values and "GetStats" again. voice_media_info.receivers[0].last_packet_received = Timestamp::Seconds(3); expected_audio.last_packet_received_timestamp = 3000.0; voice_media_info.receivers[0].estimated_playout_ntp_timestamp_ms = 4567; expected_audio.estimated_playout_timestamp = 4567; voice_media_channels.first->SetStats(voice_media_info); voice_media_channels.second->SetStats(voice_media_info); report = stats_->GetFreshStatsReport(main_thread_); ASSERT_TRUE(report->Get(expected_audio.id())); EXPECT_EQ( report->Get(expected_audio.id())->cast_to(), expected_audio); EXPECT_TRUE(report->Get(*expected_audio.transport_id)); EXPECT_TRUE(report->Get(*expected_audio.codec_id)); } TEST_P(RTCStatsCollectorTest, CollectRTCInboundRtpStreamStats_Audio_PlayoutId) { VoiceMediaInfo voice_media_info; voice_media_info.receivers.push_back(VoiceReceiverInfo()); voice_media_info.receivers[0].local_stats.push_back(SsrcReceiverInfo()); voice_media_info.receivers[0].local_stats[0].ssrc = 1; voice_media_info.receivers[0].packets_received = 123; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("AudioMid", "TransportName", voice_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->SetupRemoteTrackAndReceiver(MediaType::AUDIO, "RemoteAudioTrackID", "RemoteStreamId", 1); // Needed for playoutId to be populated. pc_->SetAudioDeviceStats(AudioDeviceModule::Stats()); { // We do not expect a playout id when only sending. pc_->GetTransceiversInternal()[0]->internal()->set_current_direction( RtpTransceiverDirection::kSendOnly); scoped_refptr report = stats_->GetStatsReport(main_thread_); ASSERT_TRUE(report->Get("ITTransportName1A1")); auto stats = report->Get("ITTransportName1A1")->cast_to(); ASSERT_FALSE(stats.playout_id.has_value()); } { // We do expect a playout id when receiving. pc_->GetTransceiversInternal()[0]->internal()->set_current_direction( RtpTransceiverDirection::kRecvOnly); scoped_refptr report = stats_->GetFreshStatsReport(main_thread_); ASSERT_TRUE(report->Get("ITTransportName1A1")); auto stats = report->Get("ITTransportName1A1")->cast_to(); ASSERT_TRUE(stats.playout_id.has_value()); EXPECT_EQ(*stats.playout_id, "AP"); } } TEST_P(RTCStatsCollectorTest, CollectRTCInboundRtpStreamStats_Video) { VideoMediaInfo video_media_info; video_media_info.receivers.push_back(VideoReceiverInfo()); video_media_info.receivers[0].local_stats.push_back(SsrcReceiverInfo()); video_media_info.receivers[0].local_stats[0].ssrc = 1; video_media_info.receivers[0].packets_received = 2; video_media_info.receivers[0].packets_received_with_ect1 = 7; video_media_info.receivers[0].packets_received_with_ce = 5; video_media_info.receivers[0].packets_lost = 42; video_media_info.receivers[0].payload_bytes_received = 3; video_media_info.receivers[0].header_and_padding_bytes_received = 12; video_media_info.receivers[0].codec_payload_type = 42; video_media_info.receivers[0].firs_sent = 5; video_media_info.receivers[0].plis_sent = 6; video_media_info.receivers[0].nacks_sent = 7; video_media_info.receivers[0].frames_received = 8; video_media_info.receivers[0].frames_decoded = 9; video_media_info.receivers[0].key_frames_decoded = 3; video_media_info.receivers[0].frames_dropped = 13; video_media_info.receivers[0].qp_sum = std::nullopt; video_media_info.receivers[0].corruption_score_sum = std::nullopt; video_media_info.receivers[0].corruption_score_squared_sum = std::nullopt; video_media_info.receivers[0].total_decode_time = TimeDelta::Seconds(9); video_media_info.receivers[0].total_processing_delay = TimeDelta::Millis(600); video_media_info.receivers[0].total_assembly_time = TimeDelta::Millis(500); video_media_info.receivers[0].frames_assembled_from_multiple_packets = 23; video_media_info.receivers[0].total_inter_frame_delay = 0.123; video_media_info.receivers[0].total_squared_inter_frame_delay = 0.00456; video_media_info.receivers[0].pause_count = 2; video_media_info.receivers[0].total_pauses_duration_ms = 10000; video_media_info.receivers[0].freeze_count = 3; video_media_info.receivers[0].total_freezes_duration_ms = 1000; video_media_info.receivers[0].jitter_ms = 1199; video_media_info.receivers[0].jitter_buffer_delay_seconds = 3.456; video_media_info.receivers[0].jitter_buffer_target_delay_seconds = 1.1; video_media_info.receivers[0].jitter_buffer_minimum_delay_seconds = 0.999; video_media_info.receivers[0].jitter_buffer_emitted_count = 13; video_media_info.receivers[0].last_packet_received = std::nullopt; video_media_info.receivers[0].content_type = VideoContentType::UNSPECIFIED; video_media_info.receivers[0].estimated_playout_ntp_timestamp_ms = std::nullopt; video_media_info.receivers[0].decoder_implementation_name = std::nullopt; video_media_info.receivers[0].min_playout_delay_ms = 50; video_media_info.receivers[0].power_efficient_decoder = false; video_media_info.receivers[0].retransmitted_packets_received = 17; video_media_info.receivers[0].retransmitted_bytes_received = 62; video_media_info.receivers[0].fec_packets_received = 32; video_media_info.receivers[0].fec_bytes_received = 54; video_media_info.receivers[0].ssrc_groups.push_back( {kFidSsrcGroupSemantics, {1, 4404}}); video_media_info.receivers[0].ssrc_groups.push_back( {kFecFrSsrcGroupSemantics, {1, 5505}}); // Note: these two values intentionally differ, // only the decoded one should show up. video_media_info.receivers[0].framerate_received = 15; video_media_info.receivers[0].framerate_decoded = 5; RtpCodecParameters codec_parameters; codec_parameters.payload_type = 42; codec_parameters.kind = MediaType::VIDEO; codec_parameters.name = "dummy"; codec_parameters.clock_rate = 0; video_media_info.receive_codecs.insert( std::make_pair(codec_parameters.payload_type, codec_parameters)); Call::Stats call_stats; call_stats.sent_ccfb_stats_per_ssrc[1] = { .num_packets_reported_lost = 222, .num_packets_reported_recovered = 200}; pc_->SetCallStats(call_stats); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); auto video_media_channels = pc_->AddVideoChannel("VideoMid", "TransportName", video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->SetupRemoteTrackAndReceiver(MediaType::VIDEO, "RemoteVideoTrackID", "RemoteStreamId", 1); scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCInboundRtpStreamStats expected_video("ITTransportName1V1", report->timestamp()); expected_video.ssrc = 1; expected_video.kind = "video"; expected_video.track_identifier = "RemoteVideoTrackID"; expected_video.mid = "VideoMid"; expected_video.transport_id = "TTransportName1"; expected_video.codec_id = "CITTransportName1_42"; expected_video.fir_count = 5; expected_video.pli_count = 6; expected_video.nack_count = 7; expected_video.packets_received = 2; expected_video.packets_received_with_ect1 = 7; expected_video.packets_received_with_ce = 5; expected_video.packets_reported_as_lost = 222; expected_video.packets_reported_as_lost_but_recovered = 200; expected_video.bytes_received = 3; expected_video.header_bytes_received = 12; expected_video.packets_lost = 42; expected_video.frames_received = 8; expected_video.frames_decoded = 9; expected_video.key_frames_decoded = 3; expected_video.frames_dropped = 13; // `expected_video.qp_sum` should be undefined. // `corruption_score` related metrics should be undefined. expected_video.total_decode_time = 9.0; expected_video.total_processing_delay = 0.6; expected_video.total_assembly_time = 0.5; expected_video.frames_assembled_from_multiple_packets = 23; expected_video.total_inter_frame_delay = 0.123; expected_video.total_squared_inter_frame_delay = 0.00456; expected_video.pause_count = 2; expected_video.total_pauses_duration = 10; expected_video.freeze_count = 3; expected_video.total_freezes_duration = 1; expected_video.jitter = 1.199; expected_video.jitter_buffer_delay = 3.456; expected_video.jitter_buffer_target_delay = 1.1; expected_video.jitter_buffer_minimum_delay = 0.999; expected_video.jitter_buffer_emitted_count = 13; // `expected_video.last_packet_received_timestamp` should be undefined. // `expected_video.content_type` should be undefined. // `expected_video.decoder_implementation` should be undefined. expected_video.min_playout_delay = 0.05; expected_video.frames_per_second = 5; expected_video.power_efficient_decoder = false; expected_video.retransmitted_packets_received = 17; expected_video.retransmitted_bytes_received = 62; expected_video.fec_packets_received = 32; expected_video.fec_bytes_received = 54; expected_video.rtx_ssrc = 4404; expected_video.fec_ssrc = 5505; ASSERT_TRUE(report->Get(expected_video.id())); EXPECT_EQ( report->Get(expected_video.id())->cast_to(), expected_video); // Set previously undefined values and "GetStats" again. video_media_info.receivers[0].qp_sum = 9; expected_video.qp_sum = 9; video_media_info.receivers[0].corruption_score_sum = 0.5; video_media_info.receivers[0].corruption_score_squared_sum = 0.25; video_media_info.receivers[0].corruption_score_count = 5; expected_video.total_corruption_probability = 0.5; expected_video.total_squared_corruption_probability = 0.25; expected_video.corruption_measurements = 5; video_media_info.receivers[0].last_packet_received = Timestamp::Seconds(1); expected_video.last_packet_received_timestamp = 1000.0; video_media_info.receivers[0].content_type = VideoContentType::SCREENSHARE; expected_video.content_type = "screenshare"; video_media_info.receivers[0].estimated_playout_ntp_timestamp_ms = 1234; expected_video.estimated_playout_timestamp = 1234; video_media_info.receivers[0].decoder_implementation_name = "libfoodecoder"; expected_video.decoder_implementation = "libfoodecoder"; video_media_info.receivers[0].power_efficient_decoder = true; expected_video.power_efficient_decoder = true; video_media_channels.first->SetStats(video_media_info); video_media_channels.second->SetStats(video_media_info); report = stats_->GetFreshStatsReport(main_thread_); ASSERT_TRUE(report->Get(expected_video.id())); EXPECT_EQ( report->Get(expected_video.id())->cast_to(), expected_video); EXPECT_TRUE(report->Get(*expected_video.transport_id)); EXPECT_TRUE(report->Get(*expected_video.codec_id)); } TEST_P(RTCStatsCollectorTest, CollectRTCAudioPlayoutStats) { AudioDeviceModule::Stats audio_device_stats; audio_device_stats.synthesized_samples_duration_s = 1; audio_device_stats.synthesized_samples_events = 2; audio_device_stats.total_samples_count = 3; audio_device_stats.total_samples_duration_s = 4; audio_device_stats.total_playout_delay_s = 5; pc_->SetAudioDeviceStats(audio_device_stats); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("AudioMid", "TransportName", {}); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->SetupRemoteTrackAndReceiver(MediaType::AUDIO, "RemoteAudioTrackID", "RemoteStreamId", 1); scoped_refptr report = stats_->GetStatsReport(main_thread_); auto stats_of_track_type = report->GetStatsOfType(); ASSERT_EQ(1U, stats_of_track_type.size()); RTCAudioPlayoutStats expected_stats("AP", report->timestamp()); expected_stats.kind = "audio"; expected_stats.synthesized_samples_duration = 1; expected_stats.synthesized_samples_events = 2; expected_stats.total_samples_count = 3; expected_stats.total_samples_duration = 4; expected_stats.total_playout_delay = 5; ASSERT_TRUE(report->Get(expected_stats.id())); EXPECT_EQ(report->Get(expected_stats.id())->cast_to(), expected_stats); } TEST_P(RTCStatsCollectorTest, CollectGoogTimingFrameInfo) { VideoMediaInfo video_media_info; video_media_info.receivers.push_back(VideoReceiverInfo()); video_media_info.receivers[0].local_stats.push_back(SsrcReceiverInfo()); video_media_info.receivers[0].local_stats[0].ssrc = 1; video_media_info.receivers[0].packets_received = 123; TimingFrameInfo timing_frame_info; timing_frame_info.rtp_timestamp = 1; timing_frame_info.capture_time_ms = 2; timing_frame_info.encode_start_ms = 3; timing_frame_info.encode_finish_ms = 4; timing_frame_info.packetization_finish_ms = 5; timing_frame_info.pacer_exit_ms = 6; timing_frame_info.network_timestamp_ms = 7; timing_frame_info.network2_timestamp_ms = 8; timing_frame_info.receive_start_ms = 9; timing_frame_info.receive_finish_ms = 10; timing_frame_info.decode_start_ms = 11; timing_frame_info.decode_finish_ms = 12; timing_frame_info.render_time_ms = 13; timing_frame_info.flags = 14; video_media_info.receivers[0].timing_frame_info = timing_frame_info; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("Mid0", "Transport0", video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->SetupRemoteTrackAndReceiver(MediaType::VIDEO, "RemoteVideoTrackID", "RemoteStreamId", 1); scoped_refptr report = stats_->GetStatsReport(main_thread_); auto inbound_rtps = report->GetStatsOfType(); ASSERT_EQ(inbound_rtps.size(), 1u); ASSERT_TRUE(inbound_rtps[0]->goog_timing_frame_info.has_value()); EXPECT_EQ(*inbound_rtps[0]->goog_timing_frame_info, "1,2,3,4,5,6,7,8,9,10,11,12,13,1,0"); } TEST_P(RTCStatsCollectorTest, CollectRTCOutboundRtpStreamStats_Audio) { VoiceMediaInfo voice_media_info; voice_media_info.senders.push_back(VoiceSenderInfo()); voice_media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); voice_media_info.senders[0].local_stats[0].ssrc = 1; voice_media_info.senders[0].packets_sent = 2; voice_media_info.senders[0].packets_sent_with_ect1 = 2; voice_media_info.senders[0].total_packet_send_delay = TimeDelta::Seconds(1); voice_media_info.senders[0].retransmitted_packets_sent = 20; voice_media_info.senders[0].payload_bytes_sent = 3; voice_media_info.senders[0].header_and_padding_bytes_sent = 12; voice_media_info.senders[0].retransmitted_bytes_sent = 30; voice_media_info.senders[0].nacks_received = 31; voice_media_info.senders[0].target_bitrate = DataRate::BitsPerSec(32'000); voice_media_info.senders[0].codec_payload_type = 42; voice_media_info.senders[0].active = true; RtpCodecParameters codec_parameters; codec_parameters.payload_type = 42; codec_parameters.kind = MediaType::AUDIO; codec_parameters.name = "dummy"; codec_parameters.clock_rate = 0; voice_media_info.send_codecs.insert( std::make_pair(codec_parameters.payload_type, codec_parameters)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("AudioMid", "TransportName", voice_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->SetupLocalTrackAndSender(MediaType::AUDIO, "LocalAudioTrackID", 1, true, /*attachment_id=*/50); scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCOutboundRtpStreamStats expected_audio("OTTransportName1A1", report->timestamp()); expected_audio.media_source_id = "SA50"; // `expected_audio.remote_id` should be undefined. expected_audio.mid = "AudioMid"; expected_audio.ssrc = 1; expected_audio.kind = "audio"; expected_audio.transport_id = "TTransportName1"; expected_audio.codec_id = "COTTransportName1_42"; expected_audio.packets_sent = 2; expected_audio.packets_sent_with_ect1 = 2; expected_audio.total_packet_send_delay = 1; expected_audio.retransmitted_packets_sent = 20; expected_audio.bytes_sent = 3; expected_audio.header_bytes_sent = 12; expected_audio.retransmitted_bytes_sent = 30; expected_audio.nack_count = 31; expected_audio.target_bitrate = 32000; expected_audio.active = true; ASSERT_TRUE(report->Get(expected_audio.id())); EXPECT_EQ( report->Get(expected_audio.id())->cast_to(), expected_audio); ASSERT_TRUE(report->Get(expected_audio.id())); EXPECT_EQ( report->Get(expected_audio.id())->cast_to(), expected_audio); EXPECT_TRUE(report->Get(*expected_audio.transport_id)); EXPECT_TRUE(report->Get(*expected_audio.codec_id)); } TEST_P(RTCStatsCollectorTest, CollectRTCOutboundRtpStreamStats_Video) { VideoMediaInfo video_media_info; video_media_info.senders.push_back(VideoSenderInfo()); video_media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); video_media_info.senders[0].local_stats[0].ssrc = 1; video_media_info.senders[0].rid = "q"; video_media_info.senders[0].encoding_index = 0; video_media_info.senders[0].firs_received = 2; video_media_info.senders[0].plis_received = 3; video_media_info.senders[0].nacks_received = 4; video_media_info.senders[0].packets_sent = 5; video_media_info.senders[0].packets_sent_with_ect1 = 3; video_media_info.senders[0].retransmitted_packets_sent = 50; video_media_info.senders[0].payload_bytes_sent = 6; video_media_info.senders[0].header_and_padding_bytes_sent = 12; video_media_info.senders[0].retransmitted_bytes_sent = 60; video_media_info.senders[0].codec_payload_type = 42; video_media_info.senders[0].frames_encoded = 8; video_media_info.senders[0].key_frames_encoded = 3; video_media_info.senders[0].total_encode_time_ms = 9000; video_media_info.senders[0].total_encoded_bytes_target = 1234; video_media_info.senders[0].total_packet_send_delay = TimeDelta::Seconds(10); video_media_info.senders[0].quality_limitation_reason = QualityLimitationReason::kBandwidth; video_media_info.senders[0] .quality_limitation_durations_ms[QualityLimitationReason::kBandwidth] = 300; video_media_info.senders[0].quality_limitation_resolution_changes = 56u; video_media_info.senders[0].qp_sum = std::nullopt; video_media_info.senders[0].psnr_measurements = 0; video_media_info.senders[0].content_type = VideoContentType::UNSPECIFIED; video_media_info.senders[0].encoder_implementation_name = std::nullopt; video_media_info.senders[0].power_efficient_encoder = false; video_media_info.senders[0].send_frame_width = 200; video_media_info.senders[0].send_frame_height = 100; video_media_info.senders[0].framerate_sent = 10; video_media_info.senders[0].frames_sent = 5; video_media_info.senders[0].huge_frames_sent = 2; video_media_info.senders[0].active = false; video_media_info.senders[0].scalability_mode = ScalabilityMode::kL3T3_KEY; video_media_info.senders[0].ssrc_groups.push_back( {kFidSsrcGroupSemantics, {1, 4404}}); video_media_info.aggregated_senders.push_back(video_media_info.senders[0]); RtpCodecParameters codec_parameters; codec_parameters.payload_type = 42; codec_parameters.kind = MediaType::AUDIO; codec_parameters.name = "dummy"; codec_parameters.clock_rate = 0; video_media_info.send_codecs.insert( std::make_pair(codec_parameters.payload_type, codec_parameters)); // Copy the sender info into a second simulcast layer and update ssrc, rid and // simulcast index to be unique. video_media_info.senders.push_back(video_media_info.senders[0]); video_media_info.senders[1].local_stats[0].ssrc = 2; video_media_info.senders[1].rid = "h"; video_media_info.senders[1].encoding_index = 1; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); auto video_media_channels = pc_->AddVideoChannel("VideoMid", "TransportName", video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); auto video_sender = stats_->SetupLocalTrackAndSender( MediaType::VIDEO, "LocalVideoTrackID", 1, true, /*attachment_id=*/50); // Set up the fake video channel to return the expected RtpParameters // containing both simulcast encodings for the primary SSRC. StreamParams sp; sp.add_ssrc(1); sp.add_ssrc(2); sp.ssrc_groups.push_back(SsrcGroup(kSimSsrcGroupSemantics, {1, 2})); video_media_channels.first->AddSendStream(sp); scoped_refptr report = stats_->GetStatsReport(main_thread_); auto stats_of_my_type = report->GetStatsOfType(); ASSERT_EQ(2U, stats_of_my_type.size()); std::string id_of_first_ssrc; for (const RTCOutboundRtpStreamStats* outbound_rtp : stats_of_my_type) { if (outbound_rtp->ssrc.value_or(0) == 1) { id_of_first_ssrc = outbound_rtp->id(); break; } } RTCOutboundRtpStreamStats expected_video(id_of_first_ssrc, report->timestamp()); expected_video.media_source_id = "SV50"; // `expected_video.remote_id` should be undefined. expected_video.mid = "VideoMid"; expected_video.rid = "q"; expected_video.encoding_index = 0; expected_video.ssrc = 1; expected_video.kind = "video"; expected_video.transport_id = "TTransportName1"; expected_video.codec_id = "COTTransportName1_42"; expected_video.fir_count = 2; expected_video.pli_count = 3; expected_video.nack_count = 4; expected_video.packets_sent = 5; expected_video.packets_sent_with_ect1 = 3; expected_video.retransmitted_packets_sent = 50; expected_video.bytes_sent = 6; expected_video.header_bytes_sent = 12; expected_video.retransmitted_bytes_sent = 60; expected_video.frames_encoded = 8; expected_video.key_frames_encoded = 3; expected_video.total_encode_time = 9.0; expected_video.total_encoded_bytes_target = 1234; expected_video.total_packet_send_delay = 10.0; expected_video.quality_limitation_reason = "bandwidth"; expected_video.quality_limitation_durations = std::map{ std::pair{"bandwidth", 0.3}, }; expected_video.quality_limitation_resolution_changes = 56u; expected_video.frame_width = 200u; expected_video.frame_height = 100u; expected_video.frames_per_second = 10.0; expected_video.frames_sent = 5; expected_video.huge_frames_sent = 2; expected_video.active = false; expected_video.power_efficient_encoder = false; expected_video.scalability_mode = "L3T3_KEY"; expected_video.rtx_ssrc = 4404; // `expected_video.content_type` should be undefined. // `expected_video.qp_sum` should be undefined. // `expected_video.psnr_sum` should be undefined. // `expected_video.psnr_measurements` should be undefined. // `expected_video.encoder_implementation` should be undefined. ASSERT_TRUE(report->Get(expected_video.id())); EXPECT_EQ( report->Get(expected_video.id())->cast_to(), expected_video); // Find the sub-stats for the second simulcast outbound RTP stream and verify // that its `media_source_id` is set. std::string id_of_second_ssrc; for (const RTCOutboundRtpStreamStats* outbound_rtp : stats_of_my_type) { if (outbound_rtp->ssrc.value_or(0) == 2) { id_of_second_ssrc = outbound_rtp->id(); break; } } ASSERT_TRUE(report->Get(id_of_second_ssrc)); auto& second_video = report->Get(id_of_second_ssrc)->cast_to(); EXPECT_TRUE(second_video.media_source_id.has_value()); EXPECT_EQ(*second_video.media_source_id, "SV50"); // Set previously undefined values and "GetStats" again. video_media_info.senders[0].qp_sum = 9; expected_video.qp_sum = 9; video_media_info.senders[0].psnr_sum = {.y = 29, .u = 30, .v = 31}; video_media_info.senders[0].psnr_measurements = 1; expected_video.psnr_sum = {{"y", 29}, {"u", 30}, {"v", 31}}; expected_video.psnr_measurements = 1; video_media_info.senders[0].content_type = VideoContentType::SCREENSHARE; expected_video.content_type = "screenshare"; video_media_info.senders[0].encoder_implementation_name = "libfooencoder"; video_media_info.aggregated_senders[0] = video_media_info.senders[0]; expected_video.encoder_implementation = "libfooencoder"; video_media_info.senders[0].power_efficient_encoder = true; expected_video.power_efficient_encoder = true; video_media_channels.first->SetStats(video_media_info); video_media_channels.second->SetStats(video_media_info); report = stats_->GetFreshStatsReport(main_thread_); ASSERT_TRUE(report->Get(expected_video.id())); EXPECT_EQ( report->Get(expected_video.id())->cast_to(), expected_video); EXPECT_TRUE(report->Get(*expected_video.transport_id)); EXPECT_TRUE(report->Get(*expected_video.codec_id)); } TEST_P(RTCStatsCollectorTest, CollectRTCTransportStats) { const char kTransportName[] = "transport"; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("audio", kTransportName); RTC_ALLOW_PLAN_B_DEPRECATION_END(); std::unique_ptr rtp_local_candidate = CreateFakeCandidate("42.42.42.42", 42, "protocol", ADAPTER_TYPE_WIFI, IceCandidateType::kHost, 42); std::unique_ptr rtp_remote_candidate = CreateFakeCandidate("42.42.42.42", 42, "protocol", ADAPTER_TYPE_UNKNOWN, IceCandidateType::kHost, 42); std::unique_ptr rtcp_local_candidate = CreateFakeCandidate("42.42.42.42", 42, "protocol", ADAPTER_TYPE_WIFI, IceCandidateType::kHost, 42); std::unique_ptr rtcp_remote_candidate = CreateFakeCandidate("42.42.42.42", 42, "protocol", ADAPTER_TYPE_UNKNOWN, IceCandidateType::kHost, 42); ConnectionInfo rtp_connection_info; rtp_connection_info.best_connection = false; rtp_connection_info.local_candidate = *rtp_local_candidate; rtp_connection_info.remote_candidate = *rtp_remote_candidate; rtp_connection_info.sent_total_bytes = 42; rtp_connection_info.recv_total_bytes = 1337; rtp_connection_info.sent_total_packets = 3; rtp_connection_info.sent_discarded_packets = 2; rtp_connection_info.packets_received = 4; TransportChannelStats rtp_transport_channel_stats; rtp_transport_channel_stats.component = ICE_CANDIDATE_COMPONENT_RTP; rtp_transport_channel_stats.ice_transport_stats.connection_infos.push_back( rtp_connection_info); rtp_transport_channel_stats.dtls_state = DtlsTransportState::kNew; rtp_transport_channel_stats.ice_transport_stats.bytes_sent = 42; rtp_transport_channel_stats.ice_transport_stats.packets_sent = 1; rtp_transport_channel_stats.ice_transport_stats.bytes_received = 1337; rtp_transport_channel_stats.ice_transport_stats.packets_received = 4; rtp_transport_channel_stats.ice_transport_stats .selected_candidate_pair_changes = 1; rtp_transport_channel_stats.ice_transport_stats.ice_local_username_fragment = "thelocalufrag"; pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats}); // Get stats without RTCP, an active connection or certificates. scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCTransportStats expected_rtp_transport( "Ttransport" + absl::StrCat(ICE_CANDIDATE_COMPONENT_RTP), report->timestamp()); expected_rtp_transport.bytes_sent = 42; expected_rtp_transport.packets_sent = 1; expected_rtp_transport.bytes_received = 1337; expected_rtp_transport.packets_received = 4; expected_rtp_transport.dtls_state = "new"; expected_rtp_transport.dtls_role = "unknown"; expected_rtp_transport.selected_candidate_pair_changes = 1; expected_rtp_transport.ice_role = "unknown"; expected_rtp_transport.ice_local_username_fragment = "thelocalufrag"; expected_rtp_transport.ice_state = "new"; ASSERT_TRUE(report->Get(expected_rtp_transport.id())); EXPECT_EQ( expected_rtp_transport, report->Get(expected_rtp_transport.id())->cast_to()); ConnectionInfo rtcp_connection_info; rtcp_connection_info.best_connection = false; rtcp_connection_info.local_candidate = *rtcp_local_candidate; rtcp_connection_info.remote_candidate = *rtcp_remote_candidate; rtcp_connection_info.sent_total_bytes = 1337; rtcp_connection_info.recv_total_bytes = 42; rtcp_connection_info.sent_total_packets = 3; rtcp_connection_info.sent_discarded_packets = 2; rtcp_connection_info.packets_received = 4; TransportChannelStats rtcp_transport_channel_stats; rtcp_transport_channel_stats.component = ICE_CANDIDATE_COMPONENT_RTCP; rtcp_transport_channel_stats.ice_transport_stats.connection_infos.push_back( rtcp_connection_info); rtcp_transport_channel_stats.dtls_state = DtlsTransportState::kConnecting; rtcp_transport_channel_stats.ice_transport_stats.bytes_sent = 1337; rtcp_transport_channel_stats.ice_transport_stats.packets_sent = 1; rtcp_transport_channel_stats.ice_transport_stats.bytes_received = 42; rtcp_transport_channel_stats.ice_transport_stats.packets_received = 4; rtcp_transport_channel_stats.ice_transport_stats.ice_local_username_fragment = "thelocalufrag"; rtcp_transport_channel_stats.ice_transport_stats.ice_state = IceTransportState::kChecking; pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats, rtcp_transport_channel_stats}); // Get stats with RTCP and without an active connection or certificates. report = stats_->GetFreshStatsReport(main_thread_); RTCTransportStats expected_rtcp_transport( "Ttransport" + absl::StrCat(ICE_CANDIDATE_COMPONENT_RTCP), report->timestamp()); expected_rtcp_transport.bytes_sent = 1337; expected_rtcp_transport.packets_sent = 1; expected_rtcp_transport.bytes_received = 42; expected_rtcp_transport.packets_received = 4; expected_rtcp_transport.dtls_state = "connecting"; expected_rtcp_transport.dtls_role = "unknown"; expected_rtcp_transport.selected_candidate_pair_changes = 0; expected_rtcp_transport.ice_role = "unknown"; expected_rtcp_transport.ice_local_username_fragment = "thelocalufrag"; expected_rtcp_transport.ice_state = "checking"; expected_rtp_transport.rtcp_transport_stats_id = expected_rtcp_transport.id(); ASSERT_TRUE(report->Get(expected_rtp_transport.id())); EXPECT_EQ( expected_rtp_transport, report->Get(expected_rtp_transport.id())->cast_to()); ASSERT_TRUE(report->Get(expected_rtcp_transport.id())); EXPECT_EQ( expected_rtcp_transport, report->Get(expected_rtcp_transport.id())->cast_to()); // Get stats with an active connection (selected candidate pair). rtcp_transport_channel_stats.ice_transport_stats.connection_infos[0] .best_connection = true; pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats, rtcp_transport_channel_stats}); report = stats_->GetFreshStatsReport(main_thread_); expected_rtcp_transport.selected_candidate_pair_id = "CP" + rtcp_local_candidate->id() + "_" + rtcp_remote_candidate->id(); ASSERT_TRUE(report->Get(expected_rtp_transport.id())); EXPECT_EQ( expected_rtp_transport, report->Get(expected_rtp_transport.id())->cast_to()); ASSERT_TRUE(report->Get(expected_rtcp_transport.id())); EXPECT_EQ( expected_rtcp_transport, report->Get(expected_rtcp_transport.id())->cast_to()); // Get stats with certificates. std::unique_ptr local_certinfo = CreateFakeCertificateAndInfoFromDers({"(local) local", "(local) chain"}); pc_->SetLocalCertificate(kTransportName, local_certinfo->certificate); std::unique_ptr remote_certinfo = CreateFakeCertificateAndInfoFromDers( {"(remote) local", "(remote) chain"}); pc_->SetRemoteCertChain( kTransportName, remote_certinfo->certificate->GetSSLCertificateChain().Clone()); report = stats_->GetFreshStatsReport(main_thread_); expected_rtp_transport.local_certificate_id = "CF" + local_certinfo->fingerprints[0]; expected_rtp_transport.remote_certificate_id = "CF" + remote_certinfo->fingerprints[0]; expected_rtcp_transport.local_certificate_id = *expected_rtp_transport.local_certificate_id; expected_rtcp_transport.remote_certificate_id = *expected_rtp_transport.remote_certificate_id; ASSERT_TRUE(report->Get(expected_rtp_transport.id())); EXPECT_EQ( expected_rtp_transport, report->Get(expected_rtp_transport.id())->cast_to()); ASSERT_TRUE(report->Get(expected_rtcp_transport.id())); EXPECT_EQ( expected_rtcp_transport, report->Get(expected_rtcp_transport.id())->cast_to()); } TEST_P(RTCStatsCollectorTest, CollectRTCTransportStatsWithCrypto) { const char kTransportName[] = "transport"; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("audio", kTransportName); RTC_ALLOW_PLAN_B_DEPRECATION_END(); std::unique_ptr rtp_local_candidate = CreateFakeCandidate("42.42.42.42", 42, "protocol", ADAPTER_TYPE_WIFI, IceCandidateType::kHost, 42); std::unique_ptr rtp_remote_candidate = CreateFakeCandidate("42.42.42.42", 42, "protocol", ADAPTER_TYPE_UNKNOWN, IceCandidateType::kHost, 42); std::unique_ptr rtcp_local_candidate = CreateFakeCandidate("42.42.42.42", 42, "protocol", ADAPTER_TYPE_WIFI, IceCandidateType::kHost, 42); std::unique_ptr rtcp_remote_candidate = CreateFakeCandidate("42.42.42.42", 42, "protocol", ADAPTER_TYPE_UNKNOWN, IceCandidateType::kHost, 42); ConnectionInfo rtp_connection_info; rtp_connection_info.best_connection = false; rtp_connection_info.local_candidate = *rtp_local_candidate; rtp_connection_info.remote_candidate = *rtp_remote_candidate; TransportChannelStats rtp_transport_channel_stats; rtp_transport_channel_stats.component = ICE_CANDIDATE_COMPONENT_RTP; rtp_transport_channel_stats.ice_transport_stats.connection_infos.push_back( rtp_connection_info); // The state must be connected in order for crypto parameters to show up. rtp_transport_channel_stats.dtls_state = DtlsTransportState::kConnected; rtp_transport_channel_stats.ice_transport_stats .selected_candidate_pair_changes = 1; rtp_transport_channel_stats.ice_transport_stats.ice_role = ICEROLE_CONTROLLING; rtp_transport_channel_stats.ice_transport_stats.ice_local_username_fragment = "thelocalufrag"; rtp_transport_channel_stats.ice_transport_stats.ice_state = IceTransportState::kConnected; rtp_transport_channel_stats.ssl_version_bytes = 0x0203; rtp_transport_channel_stats.dtls_role = SSL_CLIENT; rtp_transport_channel_stats.tls_cipher_suite_name = "TLS_RSA_WITH_AES_128_CBC_SHA"; rtp_transport_channel_stats.srtp_crypto_suite = kSrtpAes128CmSha1_80; pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats}); Call::Stats call_stats; call_stats.ccfb_messages_received = 5; pc_->SetCallStats(call_stats); // Get stats scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCTransportStats expected_rtp_transport( "Ttransport" + absl::StrCat(ICE_CANDIDATE_COMPONENT_RTP), report->timestamp()); expected_rtp_transport.dtls_state = "connected"; expected_rtp_transport.selected_candidate_pair_changes = 1; expected_rtp_transport.ice_role = "unknown"; expected_rtp_transport.bytes_sent = 0; expected_rtp_transport.bytes_received = 0; expected_rtp_transport.packets_sent = 0; expected_rtp_transport.packets_received = 0; expected_rtp_transport.ice_role = "controlling"; expected_rtp_transport.ice_local_username_fragment = "thelocalufrag"; expected_rtp_transport.ice_state = "connected"; // Crypto parameters expected_rtp_transport.tls_version = "0203"; expected_rtp_transport.dtls_role = "client"; expected_rtp_transport.dtls_cipher = "TLS_RSA_WITH_AES_128_CBC_SHA"; expected_rtp_transport.srtp_cipher = "AES_CM_128_HMAC_SHA1_80"; // CCFB stats. expected_rtp_transport.ccfb_messages_received = 5; ASSERT_TRUE(report->Get(expected_rtp_transport.id())); EXPECT_EQ( expected_rtp_transport, report->Get(expected_rtp_transport.id())->cast_to()); } TEST_P(RTCStatsCollectorTest, CollectNoStreamRTCOutboundRtpStreamStats_Audio) { VoiceMediaInfo voice_media_info; voice_media_info.senders.push_back(VoiceSenderInfo()); voice_media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); voice_media_info.senders[0].local_stats[0].ssrc = 1; voice_media_info.senders[0].packets_sent = 2; voice_media_info.senders[0].packets_sent_with_ect1 = 0; voice_media_info.senders[0].total_packet_send_delay = TimeDelta::Seconds(0.5); voice_media_info.senders[0].retransmitted_packets_sent = 20; voice_media_info.senders[0].payload_bytes_sent = 3; voice_media_info.senders[0].header_and_padding_bytes_sent = 4; voice_media_info.senders[0].retransmitted_bytes_sent = 30; voice_media_info.senders[0].nacks_received = 31; voice_media_info.senders[0].codec_payload_type = 42; voice_media_info.senders[0].active = true; RtpCodecParameters codec_parameters; codec_parameters.payload_type = 42; codec_parameters.kind = MediaType::AUDIO; codec_parameters.name = "dummy"; codec_parameters.clock_rate = 0; voice_media_info.send_codecs.insert( std::make_pair(codec_parameters.payload_type, codec_parameters)); // Emulates the case where AddTrack is used without an associated MediaStream RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("AudioMid", "TransportName", voice_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->SetupLocalTrackAndSender(MediaType::AUDIO, "LocalAudioTrackID", 1, false, /*attachment_id=*/50); scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCOutboundRtpStreamStats expected_audio("OTTransportName1A1", report->timestamp()); expected_audio.media_source_id = "SA50"; expected_audio.mid = "AudioMid"; expected_audio.ssrc = 1; expected_audio.kind = "audio"; expected_audio.transport_id = "TTransportName1"; expected_audio.codec_id = "COTTransportName1_42"; expected_audio.packets_sent = 2; expected_audio.packets_sent_with_ect1 = 0; expected_audio.total_packet_send_delay = 0.5; expected_audio.retransmitted_packets_sent = 20; expected_audio.bytes_sent = 3; expected_audio.header_bytes_sent = 4; expected_audio.retransmitted_bytes_sent = 30; expected_audio.nack_count = 31; expected_audio.active = true; ASSERT_TRUE(report->Get(expected_audio.id())); EXPECT_EQ( report->Get(expected_audio.id())->cast_to(), expected_audio); EXPECT_TRUE(report->Get(*expected_audio.transport_id)); EXPECT_TRUE(report->Get(*expected_audio.codec_id)); } TEST_P(RTCStatsCollectorTest, RTCAudioSourceStatsCollectedForSenderWithTrack) { const uint32_t kSsrc = 4; const int kAttachmentId = 42; VoiceMediaInfo voice_media_info; voice_media_info.senders.push_back(VoiceSenderInfo()); voice_media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); voice_media_info.senders[0].local_stats[0].ssrc = kSsrc; voice_media_info.senders[0].audio_level = 32767; // [0,32767] voice_media_info.senders[0].total_input_energy = 2.0; voice_media_info.senders[0].total_input_duration = 3.0; voice_media_info.senders[0].apm_statistics.echo_return_loss = 42.0; voice_media_info.senders[0].apm_statistics.echo_return_loss_enhancement = 52.0; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("AudioMid", "TransportName", voice_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); stats_->SetupLocalTrackAndSender(MediaType::AUDIO, "LocalAudioTrackID", kSsrc, false, kAttachmentId); scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCAudioSourceStats expected_audio("SA42", report->timestamp()); expected_audio.track_identifier = "LocalAudioTrackID"; expected_audio.kind = "audio"; expected_audio.audio_level = 1.0; // [0,1] expected_audio.total_audio_energy = 2.0; expected_audio.total_samples_duration = 3.0; expected_audio.echo_return_loss = 42.0; expected_audio.echo_return_loss_enhancement = 52.0; ASSERT_TRUE(report->Get(expected_audio.id())); EXPECT_EQ(report->Get(expected_audio.id())->cast_to(), expected_audio); } TEST_P(RTCStatsCollectorTest, RTCVideoSourceStatsCollectedForSenderWithTrack) { const uint32_t kSsrc = 4; const int kAttachmentId = 42; const int kVideoSourceWidth = 12; const int kVideoSourceHeight = 34; VideoMediaInfo video_media_info; video_media_info.aggregated_senders.push_back(VideoSenderInfo()); video_media_info.senders.push_back(VideoSenderInfo()); video_media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); video_media_info.senders[0].local_stats[0].ssrc = kSsrc; video_media_info.senders[0].framerate_input = 29.0; video_media_info.aggregated_senders[0].local_stats.push_back( SsrcSenderInfo()); video_media_info.aggregated_senders[0].local_stats[0].ssrc = kSsrc; video_media_info.aggregated_senders[0].framerate_input = 29.0; video_media_info.aggregated_senders[0].frames = 10001; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("VideoMid", "TransportName", video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); auto video_source = FakeVideoTrackSource::Create(false); video_source->SetSize(kVideoSourceWidth, kVideoSourceHeight); auto video_track = CreateFakeVideoTrackForStats( "LocalVideoTrackID", MediaStreamTrackInterface::kLive, video_source); scoped_refptr sender = CreateMockSender(MediaType::VIDEO, video_track, kSsrc, kAttachmentId, {}); EXPECT_CALL(*sender, DetachTrackAndGetStopTask()).WillRepeatedly([] { return nullptr; }); EXPECT_CALL(*sender, SetMediaChannel(_)).WillRepeatedly(Return()); EXPECT_CALL(*sender, SetSendCodecs(_)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCVideoSourceStats expected_video("SV42", report->timestamp()); expected_video.track_identifier = "LocalVideoTrackID"; expected_video.kind = "video"; expected_video.width = kVideoSourceWidth; expected_video.height = kVideoSourceHeight; expected_video.frames_per_second = 29.0; expected_video.frames = 10001; ASSERT_TRUE(report->Get(expected_video.id())); EXPECT_EQ(report->Get(expected_video.id())->cast_to(), expected_video); } // This test exercises the current behavior and code path, but the correct // behavior is to report frame rate even if we have no SSRC. // TODO(hbos): When we know the frame rate even if we have no SSRC, update the // expectations of this test. TEST_P(RTCStatsCollectorTest, RTCVideoSourceStatsMissingFrameRateWhenSenderHasNoSsrc) { // TODO(https://crbug.com/webrtc/8694): When 0 is no longer a magic value for // "none", update this test. const uint32_t kNoSsrc = 0; const int kAttachmentId = 42; const int kVideoSourceWidth = 12; const int kVideoSourceHeight = 34; VideoMediaInfo video_media_info; video_media_info.senders.push_back(VideoSenderInfo()); video_media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); video_media_info.senders[0].framerate_input = 29.0; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("VideoMid", "TransportName", video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); auto video_source = FakeVideoTrackSource::Create(false); video_source->SetSize(kVideoSourceWidth, kVideoSourceHeight); auto video_track = CreateFakeVideoTrackForStats( "LocalVideoTrackID", MediaStreamTrackInterface::kLive, video_source); scoped_refptr sender = CreateMockSender( MediaType::VIDEO, video_track, kNoSsrc, kAttachmentId, {}); EXPECT_CALL(*sender, DetachTrackAndGetStopTask()).WillRepeatedly([] { return nullptr; }); EXPECT_CALL(*sender, SetMediaChannel(_)).WillRepeatedly(Return()); EXPECT_CALL(*sender, SetSendCodecs(_)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); scoped_refptr report = stats_->GetStatsReport(main_thread_); ASSERT_TRUE(report->Get("SV42")); auto video_stats = report->Get("SV42")->cast_to(); EXPECT_FALSE(video_stats.frames_per_second.has_value()); EXPECT_FALSE(video_stats.frames.has_value()); } // The track not having a source is not expected to be true in practise, but // this is true in some tests relying on fakes. This test covers that code path. TEST_P(RTCStatsCollectorTest, RTCVideoSourceStatsMissingResolutionWhenTrackHasNoSource) { const uint32_t kSsrc = 4; const int kAttachmentId = 42; VideoMediaInfo video_media_info; video_media_info.senders.push_back(VideoSenderInfo()); video_media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); video_media_info.senders[0].local_stats[0].ssrc = kSsrc; video_media_info.senders[0].framerate_input = 29.0; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("VideoMid", "TransportName", video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); auto video_track = CreateFakeVideoTrackForStats( "LocalVideoTrackID", MediaStreamTrackInterface::kLive, /*source=*/nullptr); scoped_refptr sender = CreateMockSender(MediaType::VIDEO, video_track, kSsrc, kAttachmentId, {}); EXPECT_CALL(*sender, DetachTrackAndGetStopTask()).WillRepeatedly([] { return nullptr; }); EXPECT_CALL(*sender, SetMediaChannel(_)).WillRepeatedly(Return()); EXPECT_CALL(*sender, SetSendCodecs(_)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); scoped_refptr report = stats_->GetStatsReport(main_thread_); ASSERT_TRUE(report->Get("SV42")); auto video_stats = report->Get("SV42")->cast_to(); EXPECT_FALSE(video_stats.width.has_value()); EXPECT_FALSE(video_stats.height.has_value()); } TEST_P(RTCStatsCollectorTest, RTCAudioSourceStatsNotCollectedForSenderWithoutTrack) { const uint32_t kSsrc = 4; const int kAttachmentId = 42; VoiceMediaInfo voice_media_info; voice_media_info.senders.push_back(VoiceSenderInfo()); voice_media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); voice_media_info.senders[0].local_stats[0].ssrc = kSsrc; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("AudioMid", "TransportName", voice_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); scoped_refptr sender = CreateMockSender( MediaType::AUDIO, /*track=*/nullptr, kSsrc, kAttachmentId, {}); EXPECT_CALL(*sender, DetachTrackAndGetStopTask()).WillRepeatedly([] { return nullptr; }); EXPECT_CALL(*sender, SetMediaChannel(_)).WillRepeatedly(Return()); EXPECT_CALL(*sender, SetSendCodecs(_)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); scoped_refptr report = stats_->GetStatsReport(main_thread_); EXPECT_FALSE(report->Get("SA42")); } // Parameterized tests on webrtc::MediaType (audio or video) and a boolean // indicating if the stats timestamp should use the environment clock. class RTCStatsCollectorTestWithParamKind : public RTCStatsCollectorTestBase, public ::testing::WithParamInterface> { public: RTCStatsCollectorTestWithParamKind() : media_type_(std::get<0>(GetParam())) { SetStatsTimestampWithEnvironmentClock(std::get<1>(GetParam())); } std::string MediaTypeCharStr() const { switch (media_type_) { case MediaType::AUDIO: return "A"; case MediaType::VIDEO: return "V"; default: RTC_DCHECK_NOTREACHED(); return "?"; } } std::string MediaTypeKind() const { switch (media_type_) { case MediaType::AUDIO: return "audio"; case MediaType::VIDEO: return "video"; default: RTC_DCHECK_NOTREACHED(); return ""; } } // Adds a sender and channel of the appropriate kind, creating a sender info // with the report block's `source_ssrc` and report block data. void AddSenderInfoAndMediaChannel( std::string transport_name, const std::vector& report_block_datas, std::optional codec) { switch (media_type_) { case MediaType::AUDIO: { VoiceMediaInfo voice_media_info; for (const auto& report_block_data : report_block_datas) { VoiceSenderInfo sender; sender.local_stats.push_back(SsrcSenderInfo()); sender.local_stats[0].ssrc = report_block_data.source_ssrc(); if (codec.has_value()) { sender.codec_payload_type = codec->payload_type; voice_media_info.send_codecs.insert( std::make_pair(codec->payload_type, *codec)); } sender.report_block_datas.push_back(report_block_data); voice_media_info.senders.push_back(sender); } RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVoiceChannel("mid", transport_name, voice_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); return; } case MediaType::VIDEO: { VideoMediaInfo video_media_info; for (const auto& report_block_data : report_block_datas) { VideoSenderInfo sender; sender.local_stats.push_back(SsrcSenderInfo()); sender.local_stats[0].ssrc = report_block_data.source_ssrc(); if (codec.has_value()) { sender.codec_payload_type = codec->payload_type; video_media_info.send_codecs.insert( std::make_pair(codec->payload_type, *codec)); } sender.report_block_datas.push_back(report_block_data); video_media_info.aggregated_senders.push_back(sender); video_media_info.senders.push_back(sender); } RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("mid", transport_name, video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); return; } case MediaType::DATA: default: RTC_DCHECK_NOTREACHED(); } } protected: MediaType media_type_; }; // Verifies RTCRemoteInboundRtpStreamStats members that don't require // RTCCodecStats (codecId, jitter) and without setting up an RTCP transport. TEST_P(RTCStatsCollectorTestWithParamKind, RTCRemoteInboundRtpStreamStatsCollectedFromReportBlock) { constexpr TimeDelta kReportBlockTimestampUtcOffset = TimeDelta::Micros(123456789); const Timestamp kReportBlockTimestampUtc = time_controller_.GetClock()->CurrentTime() + kReportBlockTimestampUtcOffset; const Timestamp kReportBlockTimestamp = Timestamp::Micros(12345678); const uint8_t kFractionLost = 12; const TimeDelta kRoundTripTimeSample1 = TimeDelta::Millis(1'234); const TimeDelta kRoundTripTimeSample2 = TimeDelta::Seconds(13); // The report block's timestamp cannot be from the future, set the fake clock // to match. time_controller_.AdvanceTime(kReportBlockTimestampUtcOffset); uint32_t ssrcs[] = {12, 13}; std::vector report_block_datas; Call::Stats call_stats; for (uint32_t ssrc : ssrcs) { rtcp::ReportBlock report_block; // The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the // `source_ssrc`, "SSRC of the RTP packet sender". report_block.SetMediaSsrc(ssrc); report_block.SetCumulativeLost(7); report_block.SetFractionLost(kFractionLost); ReportBlockData report_block_data; report_block_data.SetReportBlock(0, report_block, kReportBlockTimestampUtc, kReportBlockTimestamp); report_block_data.AddRoundTripTimeSample(kRoundTripTimeSample1); // Only the last sample should be exposed as the // `RTCRemoteInboundRtpStreamStats::round_trip_time`. report_block_data.AddRoundTripTimeSample(kRoundTripTimeSample2); report_block_datas.push_back(report_block_data); call_stats.received_ccfb_stats_per_ssrc[ssrc] = { .num_packets_received_with_ect1 = 100, .num_packets_received_with_ce = 10, .num_packets_reported_as_lost = 30, .num_packets_reported_as_lost_but_recovered = 20, .num_packets_with_bleached_ect1_marking = 1}; } AddSenderInfoAndMediaChannel("TransportName", report_block_datas, std::nullopt); pc_->SetCallStats(call_stats); const Timestamp expected_timestamp = std::get<1>(GetParam()) ? kReportBlockTimestamp : kReportBlockTimestampUtc; scoped_refptr report = stats_->GetStatsReport(main_thread_); for (uint32_t ssrc : ssrcs) { std::string stream_id = "" + std::to_string(ssrc); RTCRemoteInboundRtpStreamStats expected_remote_inbound_rtp( "RI" + MediaTypeCharStr() + stream_id, expected_timestamp); expected_remote_inbound_rtp.ssrc = ssrc; expected_remote_inbound_rtp.fraction_lost = static_cast(kFractionLost) / (1 << 8); expected_remote_inbound_rtp.kind = MediaTypeKind(); expected_remote_inbound_rtp.transport_id = "TTransportName1"; // 1 for RTP (we have no RTCP // transport) expected_remote_inbound_rtp.packets_lost = 7; expected_remote_inbound_rtp.local_id = "OTTransportName1" + MediaTypeCharStr() + stream_id; expected_remote_inbound_rtp.round_trip_time = kRoundTripTimeSample2.seconds(); expected_remote_inbound_rtp.total_round_trip_time = (kRoundTripTimeSample1 + kRoundTripTimeSample2).seconds(); expected_remote_inbound_rtp.round_trip_time_measurements = 2; expected_remote_inbound_rtp.packets_received_with_ect1 = 100; expected_remote_inbound_rtp.packets_received_with_ce = 10; expected_remote_inbound_rtp.packets_reported_as_lost = 30; expected_remote_inbound_rtp.packets_reported_as_lost_but_recovered = 20; expected_remote_inbound_rtp.packets_with_bleached_ect1_marking = 1; // This test does not set up RTCCodecStats, so `codec_id` and `jitter` are // expected to be missing. These are tested separately. ASSERT_TRUE(report->Get(expected_remote_inbound_rtp.id())); const auto& remote_inbound_rtp = report->Get(expected_remote_inbound_rtp.id()) ->cast_to(); EXPECT_EQ(remote_inbound_rtp, expected_remote_inbound_rtp); EXPECT_EQ(remote_inbound_rtp.timestamp(), expected_timestamp); EXPECT_TRUE(report->Get(*expected_remote_inbound_rtp.transport_id)); ASSERT_TRUE(report->Get(*expected_remote_inbound_rtp.local_id)); // Lookup works in both directions. EXPECT_EQ(*report->Get(*expected_remote_inbound_rtp.local_id) ->cast_to() .remote_id, expected_remote_inbound_rtp.id()); } } TEST_P(RTCStatsCollectorTestWithParamKind, RTCRemoteInboundRtpStreamStatsRttMissingBeforeMeasurement) { const Timestamp kReportBlockTimestampUtc = Timestamp::Micros(123456789); const Timestamp kReportBlockTimestamp = Timestamp::Micros(12345678); rtcp::ReportBlock report_block; // The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the // `source_ssrc`, "SSRC of the RTP packet sender". report_block.SetMediaSsrc(12); ReportBlockData report_block_data; // AddRoundTripTimeSample() not called. report_block_data.SetReportBlock(0, report_block, kReportBlockTimestampUtc, kReportBlockTimestamp); AddSenderInfoAndMediaChannel("TransportName", {report_block_data}, std::nullopt); scoped_refptr report = stats_->GetStatsReport(main_thread_); std::string remote_inbound_rtp_id = "RI" + MediaTypeCharStr() + "12"; ASSERT_TRUE(report->Get(remote_inbound_rtp_id)); auto& remote_inbound_rtp = report->Get(remote_inbound_rtp_id) ->cast_to(); EXPECT_TRUE(remote_inbound_rtp.round_trip_time_measurements.has_value()); EXPECT_EQ(0, *remote_inbound_rtp.round_trip_time_measurements); EXPECT_FALSE(remote_inbound_rtp.round_trip_time.has_value()); } TEST_P(RTCStatsCollectorTestWithParamKind, RTCRemoteInboundRtpStreamStatsWithTimestampFromReportBlock) { const Timestamp kReportBlockTimestampUtc = Timestamp::Micros(123456789); const Timestamp kReportBlockTimestamp = Timestamp::Micros(12345678); time_controller_.AdvanceTime(kReportBlockTimestampUtc - time_controller_.GetClock()->CurrentTime()); rtcp::ReportBlock report_block; // The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the // `source_ssrc`, "SSRC of the RTP packet sender". report_block.SetMediaSsrc(12); ReportBlockData report_block_data; report_block_data.SetReportBlock(0, report_block, kReportBlockTimestampUtc, kReportBlockTimestamp); AddSenderInfoAndMediaChannel("TransportName", {report_block_data}, std::nullopt); // Advance time, it should be OK to have fresher reports than report blocks. time_controller_.AdvanceTime(TimeDelta::Micros(1234)); scoped_refptr report = stats_->GetStatsReport(main_thread_); std::string remote_inbound_rtp_id = "RI" + MediaTypeCharStr() + "12"; ASSERT_TRUE(report->Get(remote_inbound_rtp_id)); auto& remote_inbound_rtp = report->Get(remote_inbound_rtp_id) ->cast_to(); // Even though the report time is different, the remote-inbound-rtp timestamp // is of the time that the report block was received. EXPECT_EQ(report->timestamp(), kReportBlockTimestampUtc + TimeDelta::Micros(1234)); if (std::get<1>(GetParam())) { EXPECT_EQ(remote_inbound_rtp.timestamp(), kReportBlockTimestamp); } else { EXPECT_EQ(remote_inbound_rtp.timestamp(), kReportBlockTimestampUtc); } } TEST_P(RTCStatsCollectorTestWithParamKind, RTCRemoteInboundRtpStreamStatsWithCodecBasedMembers) { const Timestamp kReportBlockTimestampUtc = Timestamp::Micros(123456789); const Timestamp kReportBlockTimestamp = Timestamp::Micros(12345678); time_controller_.AdvanceTime(kReportBlockTimestampUtc - time_controller_.GetClock()->CurrentTime()); rtcp::ReportBlock report_block; // The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the // `source_ssrc`, "SSRC of the RTP packet sender". report_block.SetMediaSsrc(12); report_block.SetJitter(5000); ReportBlockData report_block_data; report_block_data.SetReportBlock(0, report_block, kReportBlockTimestampUtc, kReportBlockTimestamp); RtpCodecParameters codec; codec.payload_type = 3; codec.kind = media_type_; codec.clock_rate = 1000; AddSenderInfoAndMediaChannel("TransportName", {report_block_data}, codec); scoped_refptr report = stats_->GetStatsReport(main_thread_); std::string remote_inbound_rtp_id = "RI" + MediaTypeCharStr() + "12"; ASSERT_TRUE(report->Get(remote_inbound_rtp_id)); auto& remote_inbound_rtp = report->Get(remote_inbound_rtp_id) ->cast_to(); EXPECT_TRUE(remote_inbound_rtp.codec_id.has_value()); EXPECT_TRUE(report->Get(*remote_inbound_rtp.codec_id)); EXPECT_TRUE(remote_inbound_rtp.jitter.has_value()); // The jitter (in seconds) is the report block's jitter divided by the codec's // clock rate. EXPECT_EQ(5.0, *remote_inbound_rtp.jitter); } TEST_P(RTCStatsCollectorTestWithParamKind, RTCRemoteInboundRtpStreamStatsWithRtcpTransport) { const Timestamp kReportBlockTimestampUtc = Timestamp::Micros(123456789); const Timestamp kReportBlockTimestamp = Timestamp::Micros(12345678); time_controller_.AdvanceTime(kReportBlockTimestampUtc - time_controller_.GetClock()->CurrentTime()); rtcp::ReportBlock report_block; // The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the // `source_ssrc`, "SSRC of the RTP packet sender". report_block.SetMediaSsrc(12); ReportBlockData report_block_data; report_block_data.SetReportBlock(0, report_block, kReportBlockTimestampUtc, kReportBlockTimestamp); TransportChannelStats rtp_transport_channel_stats; rtp_transport_channel_stats.component = ICE_CANDIDATE_COMPONENT_RTP; rtp_transport_channel_stats.dtls_state = DtlsTransportState::kNew; TransportChannelStats rtcp_transport_channel_stats; rtcp_transport_channel_stats.component = ICE_CANDIDATE_COMPONENT_RTCP; rtcp_transport_channel_stats.dtls_state = DtlsTransportState::kNew; pc_->SetTransportStats("TransportName", {rtp_transport_channel_stats, rtcp_transport_channel_stats}); AddSenderInfoAndMediaChannel("TransportName", {report_block_data}, std::nullopt); scoped_refptr report = stats_->GetStatsReport(main_thread_); std::string remote_inbound_rtp_id = "RI" + MediaTypeCharStr() + "12"; ASSERT_TRUE(report->Get(remote_inbound_rtp_id)); auto& remote_inbound_rtp = report->Get(remote_inbound_rtp_id) ->cast_to(); EXPECT_TRUE(remote_inbound_rtp.transport_id.has_value()); EXPECT_EQ("TTransportName2", // 2 for RTCP *remote_inbound_rtp.transport_id); EXPECT_TRUE(report->Get(*remote_inbound_rtp.transport_id)); } INSTANTIATE_TEST_SUITE_P(All, RTCStatsCollectorTest, ::testing::Bool()); INSTANTIATE_TEST_SUITE_P(All, RTCStatsCollectorTestWithParamKind, ::testing::Combine(::testing::Values(MediaType::AUDIO, MediaType::VIDEO), ::testing::Bool())); // Checks that no remote outbound stats are collected if not available in // `VoiceMediaInfo`. TEST_P(RTCStatsCollectorTest, RTCRemoteOutboundRtpAudioStreamStatsNotCollected) { ExampleStatsGraph graph = SetupExampleStatsVoiceGraph(/*add_remote_outbound_stats=*/false); EXPECT_FALSE(graph.full_report->Get(graph.remote_outbound_rtp_id)); // Also check that no other remote outbound report is created (in case the // expected ID is incorrect). scoped_refptr report = stats_->GetStatsReport(main_thread_); ASSERT_NE(report->begin(), report->end()) << "No reports have been generated."; for (const auto& stats : *report) { SCOPED_TRACE(stats.id()); EXPECT_NE(stats.type(), RTCRemoteOutboundRtpStreamStats::kType); } } // Checks that the remote outbound stats are collected when available in // `VoiceMediaInfo`. TEST_P(RTCStatsCollectorTest, RTCRemoteOutboundRtpAudioStreamStatsCollected) { ExampleStatsGraph graph = SetupExampleStatsVoiceGraph(/*add_remote_outbound_stats=*/true); ASSERT_TRUE(graph.full_report->Get(graph.remote_outbound_rtp_id)); const auto& remote_outbound_rtp = graph.full_report->Get(graph.remote_outbound_rtp_id) ->cast_to(); EXPECT_EQ(remote_outbound_rtp.timestamp(), kRemoteOutboundStatsTimestamp); EXPECT_FLOAT_EQ(*remote_outbound_rtp.remote_timestamp, kRemoteOutboundStatsRemoteTimestamp.ms()); EXPECT_EQ(*remote_outbound_rtp.packets_sent, kRemoteOutboundStatsPacketsSent); EXPECT_EQ(*remote_outbound_rtp.bytes_sent, kRemoteOutboundStatsBytesSent); EXPECT_EQ(*remote_outbound_rtp.reports_sent, kRemoteOutboundStatsReportsCount); } TEST_P(RTCStatsCollectorTest, RTCVideoSourceStatsNotCollectedForSenderWithoutTrack) { const uint32_t kSsrc = 4; const int kAttachmentId = 42; VideoMediaInfo video_media_info; video_media_info.senders.push_back(VideoSenderInfo()); video_media_info.senders[0].local_stats.push_back(SsrcSenderInfo()); video_media_info.senders[0].local_stats[0].ssrc = kSsrc; video_media_info.senders[0].framerate_input = 29.0; RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddVideoChannel("VideoMid", "TransportName", video_media_info); RTC_ALLOW_PLAN_B_DEPRECATION_END(); scoped_refptr sender = CreateMockSender( MediaType::VIDEO, /*track=*/nullptr, kSsrc, kAttachmentId, {}); EXPECT_CALL(*sender, DetachTrackAndGetStopTask()).WillRepeatedly([] { return nullptr; }); EXPECT_CALL(*sender, SetMediaChannel(_)).WillRepeatedly(Return()); EXPECT_CALL(*sender, SetSendCodecs(_)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); scoped_refptr report = stats_->GetStatsReport(main_thread_); EXPECT_FALSE(report->Get("SV42")); } // Test collecting echo return loss stats from the audio processor attached to // the track, rather than the voice sender info. TEST_P(RTCStatsCollectorTest, CollectEchoReturnLossFromTrackAudioProcessor) { scoped_refptr local_stream = MediaStream::Create("LocalStreamId"); pc_->mutable_local_streams()->AddStream(local_stream); // Local audio track scoped_refptr local_audio_track = CreateFakeTrack( MediaType::AUDIO, "LocalAudioTrackID", MediaStreamTrackInterface::kEnded, /*create_fake_audio_processor=*/true); local_stream->AddTrack(scoped_refptr( static_cast(local_audio_track.get()))); VoiceSenderInfo voice_sender_info_ssrc1; voice_sender_info_ssrc1.local_stats.push_back(SsrcSenderInfo()); voice_sender_info_ssrc1.local_stats[0].ssrc = 1; stats_->CreateMockRtpSendersReceiversAndChannels( {std::make_pair(local_audio_track.get(), voice_sender_info_ssrc1)}, {}, {}, {}, {local_stream->id()}, {}); scoped_refptr report = stats_->GetStatsReport(main_thread_); RTCAudioSourceStats expected_audio("SA11", report->timestamp()); expected_audio.track_identifier = "LocalAudioTrackID"; expected_audio.kind = "audio"; expected_audio.audio_level = 0; expected_audio.total_audio_energy = 0; expected_audio.total_samples_duration = 0; expected_audio.echo_return_loss = 2.0; expected_audio.echo_return_loss_enhancement = 3.0; ASSERT_TRUE(report->Get(expected_audio.id())); EXPECT_EQ(report->Get(expected_audio.id())->cast_to(), expected_audio); } TEST_P(RTCStatsCollectorTest, GetStatsWithSenderSelector) { ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests(); // Expected stats graph when filtered by sender: // // media-source // ^ // | // +--------- outbound-rtp // | | // v v // codec (send) transport scoped_refptr sender_report; stats_->stats_collector().GetStatsReport( graph.sender, RTCStatsObtainer::Create(&sender_report, [&] { main_thread_.Quit(); })); main_thread_.Run(); EXPECT_TRUE(sender_report); EXPECT_EQ(sender_report->timestamp(), graph.full_report->timestamp()); EXPECT_EQ(sender_report->size(), 4u); EXPECT_TRUE(sender_report->Get(graph.send_codec_id)); EXPECT_FALSE(sender_report->Get(graph.recv_codec_id)); EXPECT_TRUE(sender_report->Get(graph.outbound_rtp_id)); EXPECT_FALSE(sender_report->Get(graph.inbound_rtp_id)); EXPECT_TRUE(sender_report->Get(graph.transport_id)); EXPECT_FALSE(sender_report->Get(graph.peer_connection_id)); EXPECT_TRUE(sender_report->Get(graph.media_source_id)); } TEST_P(RTCStatsCollectorTest, GetStatsWithReceiverSelector) { ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests(); // Expected stats graph when filtered by receiver: // // // // inbound-rtp // | | // v v // transport codec (recv) scoped_refptr receiver_report; stats_->stats_collector().GetStatsReport( graph.receiver, RTCStatsObtainer::Create(&receiver_report, [&] { main_thread_.Quit(); })); main_thread_.Run(); EXPECT_TRUE(receiver_report); EXPECT_EQ(receiver_report->size(), 3u); EXPECT_EQ(receiver_report->timestamp(), graph.full_report->timestamp()); EXPECT_FALSE(receiver_report->Get(graph.send_codec_id)); EXPECT_TRUE(receiver_report->Get(graph.recv_codec_id)); EXPECT_FALSE(receiver_report->Get(graph.outbound_rtp_id)); EXPECT_TRUE(receiver_report->Get(graph.inbound_rtp_id)); EXPECT_TRUE(receiver_report->Get(graph.transport_id)); EXPECT_FALSE(receiver_report->Get(graph.peer_connection_id)); EXPECT_FALSE(receiver_report->Get(graph.media_source_id)); } TEST_P(RTCStatsCollectorTest, GetStatsDoesNotBlockWhenFetchingSenderParameters) { // We must create a new FakePeerConnectionForStats with a separate worker // thread because the test base uses the current thread for all three, which // bypasses the thread hop and avoids the // RTC_DCHECK_DISALLOW_THREAD_BLOCKING_CALLS check. auto worker_thread = Thread::Create(); worker_thread->Start(); pc_ = make_ref_counted(env_, worker_thread.get()); SetStatsTimestampWithEnvironmentClock(GetParam()); // Create a track and a real sender to ensure we test the actual blocking // behavior in RtpSenderBase::GetParametersInternal. scoped_refptr track = CreateFakeTrack( MediaType::AUDIO, "audioTrack", MediaStreamTrackInterface::kLive); auto fake_media_channel = std::make_unique( webrtc::AudioOptions(), pc_->network_thread()); scoped_refptr sender = AudioRtpSender::Create( env_, pc_->signaling_thread(), pc_->worker_thread(), "sender_id", /*stats=*/nullptr, /*set_streams_observer=*/nullptr, /*enable_sframe_at_owner=*/nullptr, /*media_channel=*/nullptr); { ScopedOperationsBatcher worker_tasks(pc_->worker_thread()); worker_tasks.Add([&]() { fake_media_channel->AddSendStream(StreamParams::CreateLegacy(1234)); sender->SetMediaChannel(fake_media_channel.get()); }); worker_tasks.AddWithFinalizer(sender->SetSsrcTask(1234)); } sender->SetTrack(track.get()); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); scoped_refptr report; stats_->stats_collector().GetStatsReport( RTCStatsObtainer::Create(&report, [this] { main_thread_.Quit(); })); main_thread_.Run(); sender->Stop(); sender = nullptr; stats_.reset(); pc_ = nullptr; } TEST_P(RTCStatsCollectorTest, GetStatsWithNullSenderSelector) { ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests(); scoped_refptr empty_report; stats_->stats_collector().GetStatsReport( scoped_refptr(nullptr), RTCStatsObtainer::Create(&empty_report, [&] { main_thread_.Quit(); })); main_thread_.Run(); EXPECT_TRUE(empty_report); EXPECT_EQ(empty_report->timestamp(), graph.full_report->timestamp()); EXPECT_EQ(empty_report->size(), 0u); } TEST_P(RTCStatsCollectorTest, GetStatsWithNullReceiverSelector) { ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests(); scoped_refptr empty_report; stats_->stats_collector().GetStatsReport( scoped_refptr(nullptr), RTCStatsObtainer::Create(&empty_report, [&] { main_thread_.Quit(); })); main_thread_.Run(); EXPECT_TRUE(empty_report); EXPECT_EQ(empty_report->timestamp(), graph.full_report->timestamp()); EXPECT_EQ(empty_report->size(), 0u); } // Before SetLocalDescription() senders don't have an SSRC. // To simulate this case we create a mock sender with SSRC=0. TEST_P(RTCStatsCollectorTest, RtpIsMissingWhileSsrcIsZero) { scoped_refptr track = CreateFakeTrack( MediaType::AUDIO, "audioTrack", MediaStreamTrackInterface::kLive); scoped_refptr sender = CreateMockSender(MediaType::AUDIO, track, 0, 49, {}); EXPECT_CALL(*sender, DetachTrackAndGetStopTask()).WillRepeatedly([] { return nullptr; }); EXPECT_CALL(*sender, SetSendCodecs(_)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); scoped_refptr report = stats_->GetStatsReport(main_thread_); auto outbound_rtps = report->GetStatsOfType(); EXPECT_TRUE(outbound_rtps.empty()); } // We may also be in a case where the SSRC has been assigned but no // `voice_sender_info` stats exist yet. TEST_P(RTCStatsCollectorTest, DoNotCrashIfSsrcIsKnownButInfosAreStillMissing) { scoped_refptr track = CreateFakeTrack( MediaType::AUDIO, "audioTrack", MediaStreamTrackInterface::kLive); scoped_refptr sender = CreateMockSender(MediaType::AUDIO, track, 4711, 49, {}); EXPECT_CALL(*sender, DetachTrackAndGetStopTask()).WillRepeatedly([] { return nullptr; }); EXPECT_CALL(*sender, SetSendCodecs(_)); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); pc_->AddSender(sender); RTC_ALLOW_PLAN_B_DEPRECATION_END(); // We do not generate any matching voice_sender_info stats. scoped_refptr report = stats_->GetStatsReport(main_thread_); auto outbound_rtps = report->GetStatsOfType(); EXPECT_TRUE(outbound_rtps.empty()); } // Used for test below, to test calling GetStatsReport during a callback. class RecursiveCallback : public RTCStatsCollectorCallback { public: explicit RecursiveCallback(RTCStatsCollectorWrapper* stats, RunLoop& loop, absl::AnyInvocable on_complete) : stats_(stats), loop_(loop), on_complete_(std::move(on_complete)) {} void OnStatsDelivered( const scoped_refptr& report) override { stats_->GetStatsReport(loop_); called_ = true; if (on_complete_) std::move(on_complete_)(); } bool called() const { return called_; } private: RTCStatsCollectorWrapper* stats_; RunLoop& loop_; absl::AnyInvocable on_complete_; bool called_ = false; }; // Test that nothing bad happens if a callback causes GetStatsReport to be // called again recursively. Regression test for crbug.com/webrtc/8973. TEST_P(RTCStatsCollectorTest, DoNotCrashWhenGetStatsCalledDuringCallback) { int remaining = 2; auto on_complete = [&] { if (--remaining == 0) main_thread_.Quit(); }; auto callback1 = make_ref_counted( stats_.get(), main_thread_, on_complete); auto callback2 = make_ref_counted( stats_.get(), main_thread_, on_complete); stats_->stats_collector().GetStatsReport(callback1); stats_->stats_collector().GetStatsReport(callback2); main_thread_.Run(); EXPECT_TRUE(callback1->called()); EXPECT_TRUE(callback2->called()); } class RTCTestStats : public RTCStats { public: WEBRTC_RTCSTATS_DECL(RTCTestStats); RTCTestStats(const std::string& id, Timestamp timestamp) : RTCStats(id, timestamp) {} std::optional dummy_stat; }; WEBRTC_RTCSTATS_IMPL(RTCTestStats, RTCStats, "test-stats", AttributeInit("dummyStat", &dummy_stat)) // Overrides the stats collection to verify thread usage and that the resulting // partial reports are merged. class FakeRTCStatsCollector final : public RTCStatsCollector { public: static std::unique_ptr Create( PeerConnectionInternal* pc, const Environment& env, int64_t cache_lifetime_us = 50 * kNumMicrosecsPerMillisec) { return std::make_unique(pc, env, cache_lifetime_us); } FakeRTCStatsCollector(PeerConnectionInternal* pc, const Environment& env, int64_t cache_lifetime_us) : RTCStatsCollector(pc, env, cache_lifetime_us), signaling_thread_(pc->signaling_thread()), network_thread_(pc->network_thread()), callback_(make_ref_counted(this)) {} class Callback : public RTCStatsCollectorCallback { public: explicit Callback(FakeRTCStatsCollector* collector) : flag_(collector->safety_.flag()), collector_(collector) {} void OnStatsDelivered( const scoped_refptr& report) override { if (!flag_->alive()) return; collector_->OnStatsDelivered(report); } private: scoped_refptr flag_; FakeRTCStatsCollector* collector_; }; scoped_refptr callback() { return callback_; } void OnStatsDelivered(const scoped_refptr& report) { EXPECT_TRUE(signaling_thread_->IsCurrent()); MutexLock lock(&lock_); delivered_report_ = report; } bool HasVerifiedResults() { EXPECT_TRUE(signaling_thread_->IsCurrent()); MutexLock lock(&lock_); if (!delivered_report_) return false; EXPECT_EQ(produced_on_signaling_thread_, 1); EXPECT_TRUE(delivered_report_->Get("SignalingThreadStats")); produced_on_signaling_thread_ = 0; delivered_report_ = nullptr; return true; } protected: void ProducePartialResultsOnSignalingThreadImpl( Timestamp timestamp, const std::vector& transceiver_stats_infos, const std::vector& transceiver_references, const std::optional& audio_device_stats, RTCStatsReport* partial_report) override { EXPECT_TRUE(signaling_thread_->IsCurrent()); { MutexLock lock(&lock_); EXPECT_FALSE(delivered_report_); ++produced_on_signaling_thread_; } partial_report->AddStats(std::unique_ptr( new RTCTestStats("SignalingThreadStats", timestamp))); } private: Thread* const signaling_thread_; Thread* const network_thread_; ScopedTaskSafety safety_; scoped_refptr callback_; Mutex lock_; scoped_refptr delivered_report_; int produced_on_signaling_thread_ = 0; }; // Simple test that verifies that GetStatsReport() can be called and async // results delivered on the same thread. // This covers the following steps: // * Request stats // * Task posted from signaling to network thread. // * Task posted from network thread back to signaling // * Issue the `OnStatsDelivered` callback on the signaling thread. TEST(RTCStatsCollectorSafetyTest, WaitPendingRequestGetsCallback) { RunLoop loop; auto env = CreateTestEnvironment(); auto pc = make_ref_counted(env); RTCStatsCollectorWrapper wrapper(pc, env); auto callback = make_ref_counted(); EXPECT_CALL(*callback, OnStatsDelivered(_)).WillOnce([&] { loop.Quit(); }); wrapper.stats_collector().GetStatsReport(callback); loop.Run(); } // Similar to WaitPendingRequestGetsCallback except that we call // CancelPendingRequestAndGetShutdownTask to make sure the callback tasks won't // run (and callbacks not issued). This covers the following steps: // * Request stats // * Task posted from signaling to network thread. // * Task posted from network thread back to signaling // * The task for the signaling thread will be dropped, no callback. TEST(RTCStatsCollectorSafetyTest, CancelPendingRequestReturnsImmediately) { RunLoop loop; std::unique_ptr worker_and_network = Thread::Create(); worker_and_network->Start(); auto env = CreateTestEnvironment(); auto pc = make_ref_counted( env, worker_and_network.get(), worker_and_network.get()); RTCStatsCollectorWrapper wrapper(pc, env); auto callback = make_ref_counted(); // The callback that should not be called. EXPECT_CALL(*callback, OnStatsDelivered(_)).Times(0); // Let's pause the network/worker threads. Event blocker; worker_and_network->PostTask([&]() { blocker.Wait(Event::kForever); }); // Issue the GetStats call. At this point, cancellation has not been made, // this posts a task to the worker/network threads which will be blocked by // the above task. wrapper.stats_collector().GetStatsReport(callback); ScopedOperationsBatcher network_tasks(worker_and_network.get()); ScopedOperationsBatcher worker_tasks(worker_and_network.get()); // Now cancel any ongoing stats gathering operations. // This should cancel the outstanding operations and invoke pending callbacks // immediately. wrapper.stats_collector().CancelPendingRequestAndGetShutdownTasks( network_tasks, worker_tasks); // Resume the network and worker threads. blocker.Set(); // Run the cleanup tasks. network_tasks.Run(); worker_tasks.Run(); } // This covers the following steps: // * Mark the network thread as not alive (via CancelPendingRequest) // * Request stats // * Task posted from signaling to network thread. // * The task for the network thread will be dropped, no further work done. TEST(RTCStatsCollectorSafetyTest, NetworkThreadSafetyPreventsCallback) { RunLoop loop; auto env = CreateTestEnvironment(); auto pc = make_ref_counted(env); RTCStatsCollectorWrapper wrapper(pc, env); auto callback = make_ref_counted(); EXPECT_CALL(*callback, OnStatsDelivered(_)).Times(0); // Start by canceling any ongoing tasks. There aren't actually any ongoing // tasks, but this gives us the network cleanup task. ScopedOperationsBatcher network_tasks(pc->network_thread()); ScopedOperationsBatcher worker_tasks(pc->worker_thread()); wrapper.stats_collector().CancelPendingRequestAndGetShutdownTasks( network_tasks, worker_tasks); // Clean up the state on the network thread. This will have the effect of // dropping any tasks targeting the network thread. network_tasks.Run(); worker_tasks.Run(); // Now, attempt to get a stats report. This will try to post a task to the // network thread, which will be dropped. wrapper.stats_collector().GetStatsReport(callback); loop.Flush(); } TEST(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) { GlobalSimulatedTimeController time_controller{Timestamp::Seconds(1234)}; Environment env = CreateTestEnvironment({.time = &time_controller}); scoped_refptr pc = make_ref_counted(env); std::unique_ptr stats_collector = FakeRTCStatsCollector::Create(pc.get(), env); stats_collector->GetStatsReport(stats_collector->callback()); time_controller.AdvanceTime(TimeDelta::Zero()); EXPECT_TRUE(stats_collector->HasVerifiedResults()); } } // namespace } // namespace webrtc