RTCMediaStreamTrackStats.ssrcIds collected by RTCStatsCollector.

webrtc/api/rtcstatscollector_unittest.cc

 /*
  *  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 "webrtc/api/rtcstatscollector.h"
 
 #include <memory>
 #include <ostream>
 #include <string>
 #include <vector>
 
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/api/mediastream.h"
 #include "webrtc/api/mediastreamtrack.h"
 #include "webrtc/api/rtpparameters.h"
+#include "webrtc/api/rtpreceiverinterface.h"
+#include "webrtc/api/rtpsenderinterface.h"
 #include "webrtc/api/stats/rtcstats_objects.h"
 #include "webrtc/api/stats/rtcstatsreport.h"
+#include "webrtc/api/test/fakertpsenderreceiver.h"
 #include "webrtc/api/test/mock_datachannel.h"
 #include "webrtc/api/test/mock_peerconnection.h"
 #include "webrtc/api/test/mock_webrtcsession.h"
 #include "webrtc/api/test/rtcstatsobtainer.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/fakeclock.h"
 #include "webrtc/base/fakesslidentity.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/socketaddress.h"
@@ skipping 268 matching lines @@
             MediaControllerInterface::Create(cricket::MediaConfig(),
                                              worker_thread_,
                                              channel_manager_.get(),
                                              &event_log_)),
         session_(media_controller_.get()),
         pc_() {
     // Default return values for mocks.
     EXPECT_CALL(pc_, local_streams()).WillRepeatedly(Return(nullptr));
     EXPECT_CALL(pc_, remote_streams()).WillRepeatedly(Return(nullptr));
     EXPECT_CALL(pc_, session()).WillRepeatedly(Return(&session_));
+    EXPECT_CALL(pc_, GetSenders()).WillRepeatedly(Return(
+        std::vector<rtc::scoped_refptr<RtpSenderInterface>>()));
+    EXPECT_CALL(pc_, GetReceivers()).WillRepeatedly(Return(
+        std::vector<rtc::scoped_refptr<RtpReceiverInterface>>()));
     EXPECT_CALL(pc_, sctp_data_channels()).WillRepeatedly(
         ReturnRef(data_channels_));
     EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(ReturnNull());
     EXPECT_CALL(session_, GetLocalCertificate(_, _)).WillRepeatedly(
         Return(false));
     EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
         .WillRepeatedly(Return(nullptr));
   }
@@ skipping 911 matching lines @@
   remote_audio_processor_stats.echo_return_loss = 13;
   remote_audio_processor_stats.echo_return_loss_enhancement = 37;
   rtc::scoped_refptr<FakeAudioTrackForStats> remote_audio_track =
       FakeAudioTrackForStats::Create(
           "RemoteAudioTrackID",
           MediaStreamTrackInterface::TrackState::kLive,
           0,
           new FakeAudioProcessorForStats(remote_audio_processor_stats));
   remote_stream->AddTrack(remote_audio_track);
 
+  // RTP sender/receivers for local/remote track to wire up SSRCs.
+  std::vector<rtc::scoped_refptr<RtpSenderInterface>> rtp_senders;
+  rtc::scoped_refptr<FakeRtpSender> rtp_sender =
+      new FakeRtpSender(cricket::MEDIA_TYPE_AUDIO,
+                        CreateRtpParametersWithSsrc(1));
+  rtp_sender->SetTrack(local_audio_track);
+  rtp_senders.push_back(rtp_sender);
+  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> rtp_receivers;
+  rtc::scoped_refptr<FakeRtpReceiver> rtp_receiver =
+      new FakeRtpReceiver(cricket::MEDIA_TYPE_AUDIO,
+                          CreateRtpParametersWithSsrc(4));

[Taylor Brandstetter, 2017/01/04 00:36:56]

May be overkill, but you could also test what happens if an RtpReceiver's
SSRC(s) are unknown (which happens if SSRCs aren't signaled and no packets have
been received yet).

+  rtp_receiver->SetTrack(remote_audio_track);
+  rtp_receivers.push_back(rtp_receiver);
+  EXPECT_CALL(test_->pc(), GetSenders()).WillRepeatedly(
+      Return(rtp_senders));
+  EXPECT_CALL(test_->pc(), GetReceivers()).WillRepeatedly(
+      Return(rtp_receivers));
+
+  // |VoiceMediaInfo| for the above referenced SSRCs
+  MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
+  cricket::VoiceChannel voice_channel(
+      test_->worker_thread(), test_->network_thread(), test_->media_engine(),
+      voice_media_channel, nullptr, "VoiceContentName", kDefaultRtcpEnabled,
+      kDefaultSrtpRequired);
+  cricket::VoiceMediaInfo voice_media_info;
+  voice_media_info.senders.push_back(cricket::VoiceSenderInfo());
+  voice_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
+  voice_media_info.senders[0].local_stats[0].ssrc = 101010;  // noise
+  voice_media_info.senders.push_back(cricket::VoiceSenderInfo());
+  voice_media_info.senders[1].local_stats.push_back(cricket::SsrcSenderInfo());
+  voice_media_info.senders[1].local_stats[0].ssrc = 1;
+  voice_media_info.senders[1].local_stats.push_back(cricket::SsrcSenderInfo());
+  voice_media_info.senders[1].local_stats[1].ssrc = 2;
+  voice_media_info.senders[1].local_stats.push_back(cricket::SsrcSenderInfo());
+  voice_media_info.senders[1].local_stats[2].ssrc = 3;
+  voice_media_info.senders.push_back(cricket::VoiceSenderInfo());
+  voice_media_info.senders[2].local_stats.push_back(cricket::SsrcSenderInfo());
+  voice_media_info.senders[2].local_stats[0].ssrc = 202020;  // noise
+  voice_media_info.receivers.push_back(cricket::VoiceReceiverInfo());
+  voice_media_info.receivers[0].local_stats.push_back(
+      cricket::SsrcReceiverInfo());
+  voice_media_info.receivers[0].local_stats[0].ssrc = 4;
+  EXPECT_CALL(*voice_media_channel, GetStats(_))
+      .WillOnce(DoAll(SetArgPointee<0>(voice_media_info), Return(true)));
+  SessionStats session_stats;
+  session_stats.proxy_to_transport["VoiceContentName"] = "TransportName";
+  session_stats.transport_stats["TransportName"].transport_name =
+      "TransportName";
+  EXPECT_CALL(test_->session(), GetStats(_)).WillRepeatedly(Invoke(
+      [&session_stats](const ChannelNamePairs&) {
+        return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
+      }));
+  EXPECT_CALL(test_->session(), voice_channel())
+      .WillRepeatedly(Return(&voice_channel));
+
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCMediaStreamStats expected_local_stream(
       "RTCMediaStream_local_LocalStreamLabel", report->timestamp_us());
   expected_local_stream.stream_identifier = local_stream->label();
   expected_local_stream.track_ids = std::vector<std::string>();
   expected_local_stream.track_ids->push_back(
-      "RTCMediaStreamTrack_LocalAudioTrackID");
+      "RTCMediaStreamTrack_local_LocalAudioTrackID");
   ASSERT_TRUE(report->Get(expected_local_stream.id()));
   EXPECT_EQ(expected_local_stream,
             report->Get(expected_local_stream.id())->cast_to<
                 RTCMediaStreamStats>());
 
   RTCMediaStreamStats expected_remote_stream(
       "RTCMediaStream_remote_RemoteStreamLabel", report->timestamp_us());
   expected_remote_stream.stream_identifier = remote_stream->label();
   expected_remote_stream.track_ids = std::vector<std::string>();
   expected_remote_stream.track_ids->push_back(
-      "RTCMediaStreamTrack_RemoteAudioTrackID");
+      "RTCMediaStreamTrack_remote_RemoteAudioTrackID");
   ASSERT_TRUE(report->Get(expected_remote_stream.id()));
   EXPECT_EQ(expected_remote_stream,
             report->Get(expected_remote_stream.id())->cast_to<
                 RTCMediaStreamStats>());
 
   RTCMediaStreamTrackStats expected_local_audio_track(
-      "RTCMediaStreamTrack_LocalAudioTrackID", report->timestamp_us());
+      "RTCMediaStreamTrack_local_LocalAudioTrackID", report->timestamp_us());
   expected_local_audio_track.track_identifier = local_audio_track->id();
   expected_local_audio_track.remote_source = false;
   expected_local_audio_track.ended = true;
   expected_local_audio_track.detached = false;
+  expected_local_audio_track.ssrc_ids =
+      std::vector<std::string>({ "1", "2", "3" });
   expected_local_audio_track.audio_level = 1.0;
   expected_local_audio_track.echo_return_loss = 42.0;
   expected_local_audio_track.echo_return_loss_enhancement = 52.0;
   ASSERT_TRUE(report->Get(expected_local_audio_track.id()));
   EXPECT_EQ(expected_local_audio_track,
             report->Get(expected_local_audio_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 
   RTCMediaStreamTrackStats expected_remote_audio_track(
-      "RTCMediaStreamTrack_RemoteAudioTrackID", report->timestamp_us());
+      "RTCMediaStreamTrack_remote_RemoteAudioTrackID", report->timestamp_us());
   expected_remote_audio_track.track_identifier = remote_audio_track->id();
   expected_remote_audio_track.remote_source = true;
   expected_remote_audio_track.ended = false;
   expected_remote_audio_track.detached = false;
+  expected_remote_audio_track.ssrc_ids = std::vector<std::string>({ "4" });
   expected_remote_audio_track.audio_level = 0.0;
   expected_remote_audio_track.echo_return_loss = 13.0;
   expected_remote_audio_track.echo_return_loss_enhancement = 37.0;
   ASSERT_TRUE(report->Get(expected_remote_audio_track.id()));
   EXPECT_EQ(expected_remote_audio_track,
             report->Get(expected_remote_audio_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 }
 
 TEST_F(RTCStatsCollectorTest,
@@ skipping 15 matching lines @@
       FakeAudioTrackForStats::Create(
           "LocalAudioTrackID",
           MediaStreamTrackInterface::TrackState::kEnded,
           32767,
           new FakeAudioProcessorForStats(local_audio_processor_stats));
   local_stream->AddTrack(local_audio_track);
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCMediaStreamTrackStats expected_local_audio_track(
-      "RTCMediaStreamTrack_LocalAudioTrackID", report->timestamp_us());
+      "RTCMediaStreamTrack_local_LocalAudioTrackID", report->timestamp_us());
   expected_local_audio_track.track_identifier = local_audio_track->id();
   expected_local_audio_track.remote_source = false;
   expected_local_audio_track.ended = true;
   expected_local_audio_track.detached = false;
   expected_local_audio_track.audio_level = 1.0;
   // Should be undefined: |expected_local_audio_track.echo_return_loss| and
   // |expected_local_audio_track.echo_return_loss_enhancement|.
   ASSERT_TRUE(report->Get(expected_local_audio_track.id()));
   EXPECT_EQ(expected_local_audio_track,
             report->Get(expected_local_audio_track.id())->cast_to<
@@ skipping 37 matching lines @@
   remote_video_track_source_stats.input_height = 4321;
   rtc::scoped_refptr<FakeVideoTrackSourceForStats> remote_video_track_source =
       new FakeVideoTrackSourceForStats(remote_video_track_source_stats);
   rtc::scoped_refptr<FakeVideoTrackForStats> remote_video_track =
       FakeVideoTrackForStats::Create(
           "RemoteVideoTrackID",
           MediaStreamTrackInterface::TrackState::kEnded,
           remote_video_track_source);
   remote_stream->AddTrack(remote_video_track);
 
+  // RTP sender/receivers for local/remote track to wire up SSRCs.
+  std::vector<rtc::scoped_refptr<RtpSenderInterface>> rtp_senders;
+  rtc::scoped_refptr<FakeRtpSender> rtp_sender =
+      new FakeRtpSender(cricket::MEDIA_TYPE_VIDEO,
+                        CreateRtpParametersWithSsrc(42));
+  rtp_sender->SetTrack(local_video_track);
+  rtp_senders.push_back(rtp_sender);
+  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> rtp_receivers;
+  rtc::scoped_refptr<FakeRtpReceiver> rtp_receiver =
+      new FakeRtpReceiver(cricket::MEDIA_TYPE_VIDEO,
+                          CreateRtpParametersWithSsrc(43));
+  rtp_receiver->SetTrack(remote_video_track);
+  rtp_receivers.push_back(rtp_receiver);
+  EXPECT_CALL(test_->pc(), GetSenders()).WillRepeatedly(
+      Return(rtp_senders));
+  EXPECT_CALL(test_->pc(), GetReceivers()).WillRepeatedly(
+      Return(rtp_receivers));
+
+  // |VideoMediaInfo| for the above referenced SSRCs
+  MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
+  cricket::VideoChannel video_channel(
+      test_->worker_thread(), test_->network_thread(), video_media_channel,
+      nullptr, "VideoContentName", kDefaultRtcpEnabled, kDefaultSrtpRequired);
+  cricket::VideoMediaInfo video_media_info;
+  video_media_info.senders.push_back(cricket::VideoSenderInfo());
+  video_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
+  video_media_info.senders[0].local_stats[0].ssrc = 42;
+  video_media_info.receivers.push_back(cricket::VideoReceiverInfo());
+  video_media_info.receivers[0].local_stats.push_back(
+      cricket::SsrcReceiverInfo());
+  video_media_info.receivers[0].local_stats[0].ssrc = 43;
+  video_media_info.receivers[0].local_stats.push_back(
+      cricket::SsrcReceiverInfo());
+  video_media_info.receivers[0].local_stats[1].ssrc = 44;
+  EXPECT_CALL(*video_media_channel, GetStats(_))
+      .WillOnce(DoAll(SetArgPointee<0>(video_media_info), Return(true)));
+  SessionStats session_stats;
+  session_stats.proxy_to_transport["VideoContentName"] = "TransportName";
+  session_stats.transport_stats["TransportName"].transport_name =
+      "TransportName";
+  EXPECT_CALL(test_->session(), GetStats(_)).WillRepeatedly(Invoke(
+      [&session_stats](const ChannelNamePairs&) {
+        return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
+      }));
+  EXPECT_CALL(test_->session(), video_channel())
+      .WillRepeatedly(Return(&video_channel));
+
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCMediaStreamStats expected_local_stream(
       "RTCMediaStream_local_LocalStreamLabel", report->timestamp_us());
   expected_local_stream.stream_identifier = local_stream->label();
   expected_local_stream.track_ids = std::vector<std::string>();
   expected_local_stream.track_ids->push_back(
-      "RTCMediaStreamTrack_LocalVideoTrackID");
+      "RTCMediaStreamTrack_local_LocalVideoTrackID");
   ASSERT_TRUE(report->Get(expected_local_stream.id()));
   EXPECT_EQ(expected_local_stream,
             report->Get(expected_local_stream.id())->cast_to<
                 RTCMediaStreamStats>());
 
   RTCMediaStreamStats expected_remote_stream(
       "RTCMediaStream_remote_RemoteStreamLabel", report->timestamp_us());
   expected_remote_stream.stream_identifier = remote_stream->label();
   expected_remote_stream.track_ids = std::vector<std::string>();
   expected_remote_stream.track_ids->push_back(
-      "RTCMediaStreamTrack_RemoteVideoTrackID");
+      "RTCMediaStreamTrack_remote_RemoteVideoTrackID");
   ASSERT_TRUE(report->Get(expected_remote_stream.id()));
   EXPECT_EQ(expected_remote_stream,
             report->Get(expected_remote_stream.id())->cast_to<
                 RTCMediaStreamStats>());
 
   RTCMediaStreamTrackStats expected_local_video_track(
-      "RTCMediaStreamTrack_LocalVideoTrackID", report->timestamp_us());
+      "RTCMediaStreamTrack_local_LocalVideoTrackID", report->timestamp_us());
   expected_local_video_track.track_identifier = local_video_track->id();
   expected_local_video_track.remote_source = false;
   expected_local_video_track.ended = false;
   expected_local_video_track.detached = false;
+  expected_local_video_track.ssrc_ids = std::vector<std::string>({ "42" });
   expected_local_video_track.frame_width = 1234;
   expected_local_video_track.frame_height = 4321;
   ASSERT_TRUE(report->Get(expected_local_video_track.id()));
   EXPECT_EQ(expected_local_video_track,
             report->Get(expected_local_video_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 
   RTCMediaStreamTrackStats expected_remote_video_track(
-      "RTCMediaStreamTrack_RemoteVideoTrackID", report->timestamp_us());
+      "RTCMediaStreamTrack_remote_RemoteVideoTrackID", report->timestamp_us());
   expected_remote_video_track.track_identifier = remote_video_track->id();
   expected_remote_video_track.remote_source = true;
   expected_remote_video_track.ended = true;
   expected_remote_video_track.detached = false;
+  expected_remote_video_track.ssrc_ids =
+      std::vector<std::string>({ "43", "44" });
   expected_remote_video_track.frame_width = 1234;
   expected_remote_video_track.frame_height = 4321;
   ASSERT_TRUE(report->Get(expected_remote_video_track.id()));
   EXPECT_EQ(expected_remote_video_track,
             report->Get(expected_remote_video_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Audio) {
   MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
@@ skipping 553 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc