TrackMediaInfoMap added.

webrtc/api/trackmediainfomap_unittest.cc

Index: webrtc/api/trackmediainfomap_unittest.cc
diff --git a/webrtc/api/trackmediainfomap_unittest.cc b/webrtc/api/trackmediainfomap_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..18baae29d0f366e1f3d9bb60823d0d4cb760c8fd
--- /dev/null
+++ b/webrtc/api/trackmediainfomap_unittest.cc
@@ -0,0 +1,374 @@
+/*
+ *  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/trackmediainfomap.h"
+
+#include <initializer_list>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "webrtc/api/audiotrack.h"
+#include "webrtc/api/rtpreceiverinterface.h"
+#include "webrtc/api/rtpsenderinterface.h"
+#include "webrtc/api/test/mock_rtpreceiver.h"
+#include "webrtc/api/test/mock_rtpsender.h"
+#include "webrtc/api/test/fakevideotracksource.h"
+#include "webrtc/api/videotrack.h"
+#include "webrtc/base/refcount.h"
+#include "webrtc/media/base/mediachannel.h"
+#include "webrtc/test/gtest.h"
+
+namespace webrtc {
+
+namespace {
+
+RtpParameters CreateRtpParametersWithSsrcs(
+    std::initializer_list<uint32_t> ssrcs) {
+  RtpParameters params;
+  for (uint32_t ssrc : ssrcs) {
+    RtpEncodingParameters encoding_params;
+    encoding_params.ssrc = rtc::Optional<uint32_t>(ssrc);
+    params.encodings.push_back(encoding_params);
+  }
+  return params;
+}
+
+rtc::scoped_refptr<MockRtpSender> CreateMockRtpSender(
+    cricket::MediaType media_type, std::initializer_list<uint32_t> ssrcs,

[Taylor Brandstetter, 2017/01/11 22:12:05]

I didn't know about std::initializer_list, this is neat.

+    rtc::scoped_refptr<MediaStreamTrackInterface> track) {
+  uint32_t first_ssrc;
+  if (ssrcs.size()) {
+    first_ssrc = *ssrcs.begin();
+  } else {
+    first_ssrc = 0;
+  }
+  rtc::scoped_refptr<MockRtpSender> sender(
+      new rtc::RefCountedObject<MockRtpSender>());
+  EXPECT_CALL(*sender, track()).WillRepeatedly(testing::Return(track));
+  EXPECT_CALL(*sender, ssrc()).WillRepeatedly(testing::Return(first_ssrc));
+  EXPECT_CALL(*sender, media_type()).WillRepeatedly(testing::Return(
+      media_type));
+  EXPECT_CALL(*sender, GetParameters()).WillRepeatedly(testing::Return(
+      CreateRtpParametersWithSsrcs(ssrcs)));
+  return sender;
+}
+
+rtc::scoped_refptr<MockRtpReceiver> CreateMockRtpReceiver(
+    cricket::MediaType media_type, std::initializer_list<uint32_t> ssrcs,
+    rtc::scoped_refptr<MediaStreamTrackInterface> track) {
+  rtc::scoped_refptr<MockRtpReceiver> receiver(
+      new rtc::RefCountedObject<MockRtpReceiver>());
+  EXPECT_CALL(*receiver, track()).WillRepeatedly(testing::Return(track));
+  EXPECT_CALL(*receiver, media_type()).WillRepeatedly(testing::Return(
+      media_type));
+  EXPECT_CALL(*receiver, GetParameters()).WillRepeatedly(testing::Return(
+      CreateRtpParametersWithSsrcs(ssrcs)));
+  return receiver;
+}
+
+class TrackMediaInfoMapTest : public testing::Test {
+ public:
+  TrackMediaInfoMapTest()
+      : voice_media_info_(new cricket::VoiceMediaInfo()),
+        video_media_info_(new cricket::VideoMediaInfo()),
+        local_audio_track_(AudioTrack::Create("LocalAudioTrack", nullptr)),
+        remote_audio_track_(AudioTrack::Create("RemoteAudioTrack", nullptr)),
+        local_video_track_(
+            VideoTrack::Create("LocalVideoTrack",
+                               FakeVideoTrackSource::Create(false))),
+        remote_video_track_(
+            VideoTrack::Create("RemoteVideoTrack",
+                               FakeVideoTrackSource::Create(false))) {
+  }
+
+  ~TrackMediaInfoMapTest() {
+    // If we have a map the ownership has been passed to the map, only delete if
+    // |CreateMap| has not been called.
+    if (!map_) {
+      delete voice_media_info_;
+      delete video_media_info_;
+    }
+  }
+
+  void AddRtpSenderWithSsrcs(std::initializer_list<uint32_t> ssrcs,
+                             MediaStreamTrackInterface* local_track) {
+    rtc::scoped_refptr<MockRtpSender> rtp_sender = CreateMockRtpSender(
+        local_track->kind() == MediaStreamTrackInterface::kAudioKind ?
+            cricket::MEDIA_TYPE_AUDIO : cricket::MEDIA_TYPE_VIDEO,
+        ssrcs, local_track);
+    rtp_senders_.push_back(rtp_sender);
+    AddSenderInfos(ssrcs, local_track);

[Taylor Brandstetter, 2017/01/11 22:12:05]

This isn't quite right; if an RtpSender uses multiple SSRCs, there will be one
VideoSenderInfo with multiple SSRCs. There should be a 1:1 mapping between
Rtp[Sender/Receiver] and [Video/Voice][Sender/Receiver]Info, and I'm assuming
this will continue to be true in the future.

[hbos, 2017/01/12 11:03:14]

Done. Changed so that:

AddRtp[Sender/Receiver]WithSsrcs: 1 sender/receiver with multiple ssrcs, 1 info
with multiple ssrcs.

AddRtp[Senders/Receivers]OnePerSSrc: replaced by doing one
AddRtp[Sender/Receiver]WithSsrcs() call per ssrc at the call site.

+  }
+
+  void AddRtpReceiverWithSsrcs(std::initializer_list<uint32_t> ssrcs,
+                               MediaStreamTrackInterface* remote_track) {
+    rtc::scoped_refptr<MockRtpReceiver> rtp_receiver = CreateMockRtpReceiver(
+        remote_track->kind() == MediaStreamTrackInterface::kAudioKind ?
+            cricket::MEDIA_TYPE_AUDIO : cricket::MEDIA_TYPE_VIDEO,
+        ssrcs, remote_track);
+    rtp_receivers_.push_back(rtp_receiver);
+    AddReceiverInfos(ssrcs, remote_track);
+  }
+
+  void AddRtpSendersOnePerSsrc(std::initializer_list<uint32_t> ssrcs,
+                               MediaStreamTrackInterface* local_track) {
+    for (uint32_t ssrc : ssrcs) {
+      rtc::scoped_refptr<MockRtpSender> rtp_sender = CreateMockRtpSender(
+          local_track->kind() == MediaStreamTrackInterface::kAudioKind ?
+              cricket::MEDIA_TYPE_AUDIO : cricket::MEDIA_TYPE_VIDEO,
+          { ssrc }, local_track);
+      rtp_senders_.push_back(rtp_sender);
+    }
+    AddSenderInfos(ssrcs, local_track);
+  }
+
+  void AddRtpReceiverOnePerSsrc(std::initializer_list<uint32_t> ssrcs,

[Taylor Brandstetter, 2017/01/11 22:12:05]

nit: "AddRtpSendersOnePerSsrc" is plural ("senders"),
"AddRtpReceiverOncePerSsrc" isn't

[hbos, 2017/01/12 11:03:14]

Function removed.

+                                MediaStreamTrackInterface* remote_track) {
+    for (uint32_t ssrc : ssrcs) {
+      rtc::scoped_refptr<MockRtpReceiver> rtp_receiver = CreateMockRtpReceiver(
+          remote_track->kind() == MediaStreamTrackInterface::kAudioKind ?
+              cricket::MEDIA_TYPE_AUDIO : cricket::MEDIA_TYPE_VIDEO,
+          { ssrc }, remote_track);
+      rtp_receivers_.push_back(rtp_receiver);
+    }
+    AddReceiverInfos(ssrcs, remote_track);
+  }
+
+  void CreateMap() {
+    RTC_DCHECK(!map_);
+    map_.reset(new TrackMediaInfoMap(
+        std::unique_ptr<cricket::VoiceMediaInfo>(voice_media_info_),
+        std::unique_ptr<cricket::VideoMediaInfo>(video_media_info_),
+        rtp_senders_,
+        rtp_receivers_));
+  }
+
+ private:
+  void AddSenderInfos(std::initializer_list<uint32_t> ssrcs,
+                      MediaStreamTrackInterface* local_track) {
+    if (local_track->kind() == MediaStreamTrackInterface::kAudioKind) {
+      for (uint32_t ssrc : ssrcs) {
+        cricket::VoiceSenderInfo voice_sender_info;
+        voice_sender_info.local_stats.push_back(cricket::SsrcSenderInfo());
+        voice_sender_info.local_stats[0].ssrc = ssrc;
+        voice_media_info_->senders.push_back(voice_sender_info);
+      }
+    } else {
+      for (uint32_t ssrc : ssrcs) {
+        cricket::VideoSenderInfo video_sender_info;
+        video_sender_info.local_stats.push_back(cricket::SsrcSenderInfo());
+        video_sender_info.local_stats[0].ssrc = ssrc;
+        video_media_info_->senders.push_back(video_sender_info);
+      }
+    }
+  }
+
+  void AddReceiverInfos(std::initializer_list<uint32_t> ssrcs,
+                        MediaStreamTrackInterface* remote_track) {
+    if (remote_track->kind() == MediaStreamTrackInterface::kAudioKind) {
+      for (uint32_t ssrc : ssrcs) {
+        cricket::VoiceReceiverInfo voice_receiver_info;
+        voice_receiver_info.local_stats.push_back(cricket::SsrcReceiverInfo());
+        voice_receiver_info.local_stats[0].ssrc = ssrc;
+        voice_media_info_->receivers.push_back(voice_receiver_info);
+      }
+    } else {
+      for (uint32_t ssrc : ssrcs) {
+        cricket::VideoReceiverInfo video_receiver_info;
+        video_receiver_info.local_stats.push_back(cricket::SsrcReceiverInfo());
+        video_receiver_info.local_stats[0].ssrc = ssrc;
+        video_media_info_->receivers.push_back(video_receiver_info);
+      }
+    }
+  }
+
+ protected:
+  cricket::VoiceMediaInfo* voice_media_info_;
+  cricket::VideoMediaInfo* video_media_info_;
+  std::vector<rtc::scoped_refptr<RtpSenderInterface>> rtp_senders_;
+  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> rtp_receivers_;
+  std::unique_ptr<TrackMediaInfoMap> map_;
+  rtc::scoped_refptr<AudioTrack> local_audio_track_;
+  rtc::scoped_refptr<AudioTrack> remote_audio_track_;
+  rtc::scoped_refptr<VideoTrack> local_video_track_;
+  rtc::scoped_refptr<VideoTrack> remote_video_track_;
+};
+
+}  // namespace
+
+TEST_F(TrackMediaInfoMapTest, SingleSenderAndReceiverWithOneSsrc) {
+  AddRtpSenderWithSsrcs({ 1 }, local_audio_track_);
+  AddRtpReceiverWithSsrcs({ 2 }, remote_audio_track_);
+  AddRtpSenderWithSsrcs({ 3 }, local_video_track_);
+  AddRtpReceiverWithSsrcs({ 4 }, remote_video_track_);
+  CreateMap();
+
+  // Local audio track <-> RTP audio sender
+  ASSERT_TRUE(map_->GetVoiceSenderInfos(*local_audio_track_));
+  EXPECT_EQ(*map_->GetVoiceSenderInfos(*local_audio_track_),
+            std::vector<cricket::VoiceSenderInfo*>({
+                &voice_media_info_->senders[0] }));
+  EXPECT_EQ(map_->GetAudioTrack(voice_media_info_->senders[0]),
+            local_audio_track_.get());
+
+  // Remote audio track <-> RTP audio receiver
+  EXPECT_EQ(map_->GetVoiceReceiverInfo(*remote_audio_track_),
+            &voice_media_info_->receivers[0]);
+  EXPECT_EQ(map_->GetAudioTrack(voice_media_info_->receivers[0]),
+            remote_audio_track_.get());
+
+  // Local video track <-> RTP video sender
+  ASSERT_TRUE(map_->GetVideoSenderInfos(*local_video_track_));
+  EXPECT_EQ(*map_->GetVideoSenderInfos(*local_video_track_),
+            std::vector<cricket::VideoSenderInfo*>({
+                &video_media_info_->senders[0] }));
+  EXPECT_EQ(map_->GetVideoTrack(video_media_info_->senders[0]),
+            local_video_track_.get());
+
+  // Remote video track <-> RTP video receiver
+  EXPECT_EQ(map_->GetVideoReceiverInfo(*remote_video_track_),
+            &video_media_info_->receivers[0]);
+  EXPECT_EQ(map_->GetVideoTrack(video_media_info_->receivers[0]),
+            remote_video_track_.get());
+}
+
+TEST_F(TrackMediaInfoMapTest, SingleSenderWithMissingSsrc) {
+  AddRtpSenderWithSsrcs({}, local_audio_track_);
+  AddRtpSenderWithSsrcs({}, local_video_track_);
+  CreateMap();
+
+  EXPECT_FALSE(map_->GetVoiceSenderInfos(*local_audio_track_));
+  EXPECT_FALSE(map_->GetVideoSenderInfos(*local_video_track_));
+}
+
+TEST_F(TrackMediaInfoMapTest, SingleSenderAudioAndVideoUseSameSsrc) {
+  AddRtpSenderWithSsrcs({ 1 }, local_audio_track_);
+  AddRtpReceiverWithSsrcs({ 2 }, remote_audio_track_);
+  AddRtpSenderWithSsrcs({ 1 }, local_video_track_);
+  AddRtpReceiverWithSsrcs({ 2 }, remote_video_track_);
+  CreateMap();
+
+  // Local audio track <-> RTP audio sender
+  ASSERT_TRUE(map_->GetVoiceSenderInfos(*local_audio_track_));
+  EXPECT_EQ(*map_->GetVoiceSenderInfos(*local_audio_track_),
+            std::vector<cricket::VoiceSenderInfo*>({
+                &voice_media_info_->senders[0] }));
+  EXPECT_EQ(map_->GetAudioTrack(voice_media_info_->senders[0]),
+            local_audio_track_.get());
+
+  // Remote audio track <-> RTP audio receiver
+  EXPECT_EQ(map_->GetVoiceReceiverInfo(*remote_audio_track_),
+            &voice_media_info_->receivers[0]);
+  EXPECT_EQ(map_->GetAudioTrack(voice_media_info_->receivers[0]),
+            remote_audio_track_.get());
+
+  // Local video track <-> RTP video sender
+  ASSERT_TRUE(map_->GetVideoSenderInfos(*local_video_track_));
+  EXPECT_EQ(*map_->GetVideoSenderInfos(*local_video_track_),
+            std::vector<cricket::VideoSenderInfo*>({
+                &video_media_info_->senders[0] }));
+  EXPECT_EQ(map_->GetVideoTrack(video_media_info_->senders[0]),
+            local_video_track_.get());
+
+  // Remote video track <-> RTP video receiver
+  EXPECT_EQ(map_->GetVideoReceiverInfo(*remote_video_track_),
+            &video_media_info_->receivers[0]);
+  EXPECT_EQ(map_->GetVideoTrack(video_media_info_->receivers[0]),
+            remote_video_track_.get());
+}
+
+TEST_F(TrackMediaInfoMapTest, SingleSenderWithMultipleSsrcs) {
+  AddRtpSenderWithSsrcs({ 1, 2 }, local_audio_track_);
+  AddRtpSenderWithSsrcs({ 3, 4 }, local_video_track_);
+  CreateMap();
+
+  // Local audio track <-> RTP audio senders
+  ASSERT_TRUE(map_->GetVoiceSenderInfos(*local_audio_track_));
+  EXPECT_EQ(*map_->GetVoiceSenderInfos(*local_audio_track_),
+            std::vector<cricket::VoiceSenderInfo*>({
+                &voice_media_info_->senders[0],
+                &voice_media_info_->senders[1] }));
+  EXPECT_EQ(map_->GetAudioTrack(voice_media_info_->senders[0]),
+            local_audio_track_.get());
+  EXPECT_EQ(map_->GetAudioTrack(voice_media_info_->senders[1]),
+            local_audio_track_.get());
+
+  // Local video track <-> RTP video senders
+  ASSERT_TRUE(map_->GetVideoSenderInfos(*local_video_track_));
+  EXPECT_EQ(*map_->GetVideoSenderInfos(*local_video_track_),
+            std::vector<cricket::VideoSenderInfo*>({
+                &video_media_info_->senders[0],
+                &video_media_info_->senders[1] }));
+  EXPECT_EQ(map_->GetVideoTrack(video_media_info_->senders[0]),
+            local_video_track_.get());
+  EXPECT_EQ(map_->GetVideoTrack(video_media_info_->senders[1]),
+            local_video_track_.get());
+}
+
+TEST_F(TrackMediaInfoMapTest, MultipleSendersWithOneSsrc) {
+  AddRtpSendersOnePerSsrc({ 1, 2 }, local_audio_track_);
+  AddRtpSendersOnePerSsrc({ 3, 4 }, local_video_track_);
+  CreateMap();
+
+  // Local audio track <-> RTP audio senders
+  ASSERT_TRUE(map_->GetVoiceSenderInfos(*local_audio_track_));
+  EXPECT_EQ(*map_->GetVoiceSenderInfos(*local_audio_track_),
+            std::vector<cricket::VoiceSenderInfo*>({
+                &voice_media_info_->senders[0],
+                &voice_media_info_->senders[1] }));
+  EXPECT_EQ(map_->GetAudioTrack(voice_media_info_->senders[0]),
+            local_audio_track_.get());
+  EXPECT_EQ(map_->GetAudioTrack(voice_media_info_->senders[1]),
+            local_audio_track_.get());
+
+  // Local video track <-> RTP video senders
+  ASSERT_TRUE(map_->GetVideoSenderInfos(*local_video_track_));
+  EXPECT_EQ(*map_->GetVideoSenderInfos(*local_video_track_),
+            std::vector<cricket::VideoSenderInfo*>({
+                &video_media_info_->senders[0],
+                &video_media_info_->senders[1] }));
+  EXPECT_EQ(map_->GetVideoTrack(video_media_info_->senders[0]),
+            local_video_track_.get());
+  EXPECT_EQ(map_->GetVideoTrack(video_media_info_->senders[1]),
+            local_video_track_.get());
+}
+
+// Death tests.
+// Disabled on Android because death tests misbehave on Android, see
+// base/test/gtest_util.h.
+#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)

[Taylor Brandstetter, 2017/01/11 22:12:05]

Is it common to have tests for DCHECKs? I haven't seen that before, but it makes
sense.

[hbos, 2017/01/12 11:03:14]

This exact #if statement is commonly used for death tests. Copied from
elsewhere.

+
+class TrackMediaInfoMapDeathTest : public TrackMediaInfoMapTest {
+};
+
+TEST_F(TrackMediaInfoMapDeathTest, SingleReceiverWithMultipleSsrcs) {
+  AddRtpReceiverWithSsrcs({ 1, 2 }, remote_audio_track_);
+  AddRtpReceiverWithSsrcs({ 3, 4 }, remote_video_track_);
+  EXPECT_DEATH(CreateMap(), "");
+}
+
+TEST_F(TrackMediaInfoMapDeathTest, MultipleReceiversWithOneSsrc) {

[Taylor Brandstetter, 2017/01/11 22:12:05]

Maybe MultipleReceiversWithSameTrack would be a more fitting name?

[hbos, 2017/01/12 11:03:14]

Need to take into account # senders/receivers and # ssrcs per sender/receiver
without it sounding like it's the # ssrcs per track and without a silly long
name.

New naming convention:
[Single/Multiple][One/Multi]Ssrc[Sender(s)/Receiver(s)]PerTrack

+  AddRtpReceiverOnePerSsrc({ 1, 2 }, remote_audio_track_);
+  AddRtpReceiverOnePerSsrc({ 3, 4 }, remote_video_track_);
+  EXPECT_DEATH(CreateMap(), "");
+}
+
+TEST_F(TrackMediaInfoMapDeathTest, SingleSenderAndReceiverWithSsrcNotUnique) {
+  AddRtpSenderWithSsrcs({ 1 }, local_audio_track_);
+  AddRtpReceiverWithSsrcs({ 1 }, remote_audio_track_);
+  AddRtpSenderWithSsrcs({ 1 }, local_video_track_);
+  AddRtpReceiverWithSsrcs({ 1 }, remote_video_track_);
+  EXPECT_DEATH(CreateMap(), "");
+}
+
+#endif  // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
+
+}  // namespace webrtc