Create RtcpDemuxer

webrtc/call/rtcp_demuxer_unittest.cc

Index: webrtc/call/rtcp_demuxer_unittest.cc
diff --git a/webrtc/call/rtcp_demuxer_unittest.cc b/webrtc/call/rtcp_demuxer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..016bf49d5198744ac14133477b6db5fdeea30e42
--- /dev/null
+++ b/webrtc/call/rtcp_demuxer_unittest.cc
@@ -0,0 +1,607 @@
+/*
+ *  Copyright (c) 2017 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 <memory>
+
+#include "webrtc/call/rtcp_demuxer.h"
+
+#include "webrtc/base/arraysize.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/base/ptr_util.h"
+#include "webrtc/call/rtcp_packet_sink_interface.h"
+#include "webrtc/common_types.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
+#include "webrtc/test/gmock.h"
+#include "webrtc/test/gtest.h"
+
+namespace webrtc {
+
+namespace {
+
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::InSequence;
+using ::testing::NiceMock;
+using ::webrtc::rtcp::RtcpPacket;
+
+class MockRtcpPacketSink : public RtcpPacketSinkInterface {
+ public:
+  MOCK_METHOD1(OnRtcpPacket, void(rtc::ArrayView<const uint8_t>));
+};
+
+MATCHER_P(SameAs, other, "") {

[danilchap, 2017/06/16 16:46:19]

there is a matcher that checks same (but with a detailed error message):
ElementsAreArray

[eladalon, 2017/06/19 11:28:46]

Done.

+  if (arg.size() != other.size()) {
+    return false;
+  }
+
+  for (size_t i = 0; i < arg.size(); i++) {
+    if (arg.data()[i] != other.data()[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// Produces a packet buffer representing an RTCP packet with a given SSRC,
+// as it would look when sent over the wire.
+// |distinguishing_string| allows different RTCP packets with the same SSRC
+// to be distinguished. How this is set into the actual packet is
+// unimportant, and depends on which RTCP message we choose to use.
+rtc::Buffer CreateRtcpPacket(uint32_t ssrc,
+                             const std::string& distinguishing_string = "") {
+  auto packet = rtc::MakeUnique<rtcp::Bye>();

[danilchap, 2017/06/16 16:46:19]

why create packet on the heap instead of in the stack?
i.e. may be
rtcp::Bye packet;
...
return packet.Build();

[eladalon, 2017/06/19 11:28:47]

Right you are. An earlier version of this function returned the rtcp::Bye
itself, so that's why it was written like that. After transitioning to returning
rtc::Buffer, it's indeed unnecessary.

+  packet->SetSenderSsrc(ssrc);
+  if (distinguishing_string != "") {
+    // Actual way we use |distinguishing_string| is unimportant, so long
+    // as it ends up in the packet.
+    packet->SetReason(distinguishing_string);
+  }
+  return packet->Build();
+}
+
+// Converts a buffer to an ArrayView<const uint8_t>, which is the format
+// expected by the demuxer and the sinks. Note that an ArrayView does not own
+// the array it peeks into, which is why we could not have returned an ArrayView
+// directly from CreateRtcpPacket().
+rtc::ArrayView<const uint8_t> GetArrayView(const rtc::Buffer& buffer) {

[danilchap, 2017/06/16 16:46:19]

one of the the key features of ArrayView - it has implicit conversion from
anything that has data() and size() functions (including rtc::Buffer)

[eladalon, 2017/06/19 11:28:47]

Acknowledged (and used).

+  return rtc::ArrayView<const uint8_t>(buffer.data(), buffer.size());
+}
+
+}  // namespace
+
+TEST(RtcpDemuxerTest, OnRtcpPacketCalledOnCorrectSinkBySsrc) {
+  RtcpDemuxer demuxer;
+
+  constexpr uint32_t ssrcs[] = {101, 202, 303};
+  MockRtcpPacketSink sinks[arraysize(ssrcs)];
+  for (size_t i = 0; i < arraysize(ssrcs); i++) {
+    demuxer.AddSink(ssrcs[i], &sinks[i]);
+  }
+
+  for (size_t i = 0; i < arraysize(ssrcs); i++) {
+    auto packet = CreateRtcpPacket(ssrcs[i]);
+    auto array_view = GetArrayView(packet);
+    EXPECT_CALL(sinks[i], OnRtcpPacket(SameAs(array_view))).Times(1);
+    demuxer.OnRtcpPacket(array_view);  // Triggers call to OnRtcpPacket().
+  }
+
+  // Test tear-down
+  for (const auto& sink : sinks) {
+    demuxer.RemoveSink(&sink);
+  }
+}
+
+TEST(RtcpDemuxerTest, OnRtcpPacketCalledOnResolvedRsidSink) {
+  RtcpDemuxer demuxer;
+
+  // Set up some RSID sinks.
+  const std::string rsids[] = {"a", "b", "c"};
+  MockRtcpPacketSink sinks[arraysize(rsids)];
+  for (size_t i = 0; i < arraysize(rsids); i++) {
+    demuxer.AddSink(rsids[i], &sinks[i]);
+  }
+
+  // Only resolve one of the sinks.
+  constexpr size_t resolved_sink_index = 0;
+  constexpr uint32_t ssrc = 345;
+  demuxer.OnRsidResolved(rsids[resolved_sink_index], ssrc);
+
+  // The resolved sink gets notifications of RTCP messages with its SSRC.
+  auto packet = CreateRtcpPacket(ssrc);
+  auto array_view = GetArrayView(packet);
+  EXPECT_CALL(sinks[resolved_sink_index], OnRtcpPacket(SameAs(array_view)))
+      .Times(1);
+
+  // RTCP received; expected calls triggered.
+  demuxer.OnRtcpPacket(array_view);
+
+  // Test tear-down
+  for (const auto& sink : sinks) {
+    demuxer.RemoveSink(&sink);
+  }
+}
+
+TEST(RtcpDemuxerTest,
+     SingleCallbackAfterResolutionOfAnRsidToAlreadyRegisteredSsrc) {
+  RtcpDemuxer demuxer;
+
+  // Associate a sink with an SSRC.
+  MockRtcpPacketSink sink;
+  constexpr uint32_t ssrc = 999;
+  demuxer.AddSink(ssrc, &sink);
+
+  // Associate the same sink with an RSID.
+  const std::string rsid = "r";
+  demuxer.AddSink(rsid, &sink);
+
+  // Resolve the RSID to the aforementioned SSRC.
+  demuxer.OnRsidResolved(rsid, ssrc);
+
+  // OnRtcpPacket still called only a single time for messages with this SSRC.
+  auto packet = CreateRtcpPacket(ssrc);
+  auto array_view = GetArrayView(packet);
+  EXPECT_CALL(sink, OnRtcpPacket(array_view)).Times(1);
+  demuxer.OnRtcpPacket(array_view);
+
+  // Test tear-down
+  demuxer.RemoveSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, OnRtcpPacketCalledOnAllBroadcastSinksForAllRtcpPackets) {
+  RtcpDemuxer demuxer;
+
+  MockRtcpPacketSink sinks[3];
+  for (MockRtcpPacketSink& sink : sinks) {
+    demuxer.AddBroadcastSink(&sink);
+  }
+
+  constexpr uint32_t ssrc = 747;
+  auto packet = CreateRtcpPacket(ssrc);
+  auto array_view = GetArrayView(packet);
+
+  for (MockRtcpPacketSink& sink : sinks) {
+    EXPECT_CALL(sink, OnRtcpPacket(SameAs(array_view))).Times(1);
+  }
+
+  // RTCP received; expected calls triggered.
+  demuxer.OnRtcpPacket(array_view);
+
+  // Test tear-down
+  for (const auto& sink : sinks) {
+    demuxer.RemoveBroadcastSink(&sink);
+  }
+}
+
+TEST(RtcpDemuxerTest, PacketsDeliveredInRightOrderToNonBroadcastSink) {
+  RtcpDemuxer demuxer;
+
+  constexpr uint32_t ssrc = 101;
+  MockRtcpPacketSink sink;
+  demuxer.AddSink(ssrc, &sink);
+
+  std::vector<rtc::Buffer> packets;
+  std::vector<rtc::ArrayView<const uint8_t>> array_views;
+  for (size_t i = 0; i < 5; i++) {
+    packets.emplace_back(CreateRtcpPacket(ssrc, std::to_string(i)));
+    array_views.emplace_back(GetArrayView(packets[i]));
+  }
+
+  InSequence sequence;
+  for (size_t i = 0; i < 5; i++) {
+    EXPECT_CALL(sink, OnRtcpPacket(SameAs(array_views[i]))).Times(1);
+  }
+
+  for (const auto array_view : array_views) {
+    demuxer.OnRtcpPacket(array_view);
+  }
+
+  // Test tear-down
+  demuxer.RemoveSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, PacketsDeliveredInRightOrderToBroadcastSink) {
+  RtcpDemuxer demuxer;
+
+  MockRtcpPacketSink sink;
+  demuxer.AddBroadcastSink(&sink);
+
+  std::vector<rtc::Buffer> packets;
+  std::vector<rtc::ArrayView<const uint8_t>> array_views;
+  for (size_t i = 0; i < 5; i++) {
+    constexpr uint32_t ssrc = 101;
+    packets.emplace_back(CreateRtcpPacket(ssrc, std::to_string(i)));
+    array_views.emplace_back(GetArrayView(packets[i]));
+  }
+
+  InSequence sequence;
+  for (size_t i = 0; i < 5; i++) {
+    EXPECT_CALL(sink, OnRtcpPacket(SameAs(array_views[i]))).Times(1);
+  }
+
+  for (const auto array_view : array_views) {
+    demuxer.OnRtcpPacket(array_view);
+  }
+
+  // Test tear-down
+  demuxer.RemoveBroadcastSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, MultipleSinksMappedToSameSsrc) {
+  RtcpDemuxer demuxer;
+
+  MockRtcpPacketSink sinks[3];
+  constexpr uint32_t ssrc = 404;
+  for (auto& sink : sinks) {
+    demuxer.AddSink(ssrc, &sink);
+  }
+
+  // Reception of an RTCP packet associated with the shared SSRC triggers the
+  // callback on all of the sinks associated with it.
+  auto packet = CreateRtcpPacket(ssrc);
+  auto array_view = GetArrayView(packet);
+  for (auto& sink : sinks) {
+    EXPECT_CALL(sink, OnRtcpPacket(SameAs(array_view)));
+  }
+  demuxer.OnRtcpPacket(array_view);
+
+  // Test tear-down
+  for (const auto& sink : sinks) {
+    demuxer.RemoveSink(&sink);
+  }
+}
+
+TEST(RtcpDemuxerTest, SinkMappedToMultipleSsrcs) {
+  RtcpDemuxer demuxer;
+
+  constexpr uint32_t ssrcs[] = {404, 505, 606};
+  MockRtcpPacketSink sink;
+  for (uint32_t ssrc : ssrcs) {
+    demuxer.AddSink(ssrc, &sink);
+  }
+
+  // The sink which is associated with multiple SSRCs gets the callback
+  // triggered for each of those SSRCs.
+  for (uint32_t ssrc : ssrcs) {
+    auto packet = CreateRtcpPacket(ssrc);
+    auto array_view = GetArrayView(packet);
+    EXPECT_CALL(sink, OnRtcpPacket(SameAs(array_view)));
+    demuxer.OnRtcpPacket(array_view);
+  }
+
+  // Test tear-down
+  demuxer.RemoveSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, MultipleRsidsOnSameSink) {
+  RtcpDemuxer demuxer;
+
+  // Sink associated with multiple sinks.
+  MockRtcpPacketSink sink;
+  const std::string rsids[] = {"a", "b", "c"};
+  for (const auto& rsid : rsids) {
+    demuxer.AddSink(rsid, &sink);
+  }
+
+  // RSIDs resolved to SSRCs.
+  uint32_t ssrcs[arraysize(rsids)];
+  for (size_t i = 0; i < arraysize(rsids); i++) {
+    ssrcs[i] = 1000 + static_cast<uint32_t>(i);
+    demuxer.OnRsidResolved(rsids[i], ssrcs[i]);
+  }
+
+  // Set up packets to match those RSIDs/SSRCs.
+  std::vector<rtc::Buffer> packets;
+  std::vector<rtc::ArrayView<const uint8_t>> array_views;
+  for (size_t i = 0; i < arraysize(rsids); i++) {
+    packets.emplace_back(CreateRtcpPacket(ssrcs[i]));
+    array_views.emplace_back(GetArrayView(packets[i]));
+  }
+
+  // The sink expects to receive all of the packets.
+  for (size_t i = 0; i < arraysize(rsids); i++) {
+    EXPECT_CALL(sink, OnRtcpPacket(SameAs(array_views[i]))).Times(1);
+  }
+
+  // Packet demuxed correctly; OnRtcpPacket() triggered on sink.
+  for (auto array_view : array_views) {
+    demuxer.OnRtcpPacket(array_view);
+  }
+
+  // Test tear-down
+  demuxer.RemoveSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, RsidUsedByMultipleSinks) {
+  RtcpDemuxer demuxer;
+
+  MockRtcpPacketSink sinks[3];
+  const std::string shared_rsid = "a";
+
+  for (MockRtcpPacketSink& sink : sinks) {
+    demuxer.AddSink(shared_rsid, &sink);
+  }
+
+  constexpr uint32_t shared_ssrc = 888;
+  demuxer.OnRsidResolved(shared_rsid, shared_ssrc);
+
+  auto packet = CreateRtcpPacket(shared_ssrc);
+  auto array_view = GetArrayView(packet);
+
+  for (MockRtcpPacketSink& sink : sinks) {
+    EXPECT_CALL(sink, OnRtcpPacket(SameAs(array_view))).Times(1);
+  }
+
+  demuxer.OnRtcpPacket(array_view);
+
+  // Test tear-down
+  for (MockRtcpPacketSink& sink : sinks) {
+    demuxer.RemoveSink(&sink);
+  }
+}
+
+TEST(RtcpDemuxerTest, NoCallbackOnSsrcSinkRemovedBeforeFirstPacket) {
+  RtcpDemuxer demuxer;
+
+  constexpr uint32_t ssrc = 404;
+  MockRtcpPacketSink sink;
+  demuxer.AddSink(ssrc, &sink);
+
+  demuxer.RemoveSink(&sink);
+
+  // The removed sink does not get callbacks.
+  auto packet = CreateRtcpPacket(ssrc);
+  auto array_view = GetArrayView(packet);
+  EXPECT_CALL(sink, OnRtcpPacket(_)).Times(0);  // Not called.
+  demuxer.OnRtcpPacket(array_view);
+}
+
+TEST(RtcpDemuxerTest, NoCallbackOnSsrcSinkRemovedAfterFirstPacket) {
+  RtcpDemuxer demuxer;
+
+  constexpr uint32_t ssrc = 404;
+  NiceMock<MockRtcpPacketSink> sink;
+  demuxer.AddSink(ssrc, &sink);
+
+  auto before_packet = CreateRtcpPacket(ssrc);
+  auto before_array_view = GetArrayView(before_packet);
+  demuxer.OnRtcpPacket(before_array_view);
+
+  demuxer.RemoveSink(&sink);
+
+  // The removed sink does not get callbacks.
+  auto after_packet = CreateRtcpPacket(ssrc);
+  auto after_array_view = GetArrayView(after_packet);
+  EXPECT_CALL(sink, OnRtcpPacket(_)).Times(0);  // Not called.
+  demuxer.OnRtcpPacket(after_array_view);
+}
+
+TEST(RtcpDemuxerTest, NoCallbackOnRsidSinkRemovedBeforeRsidResolution) {
+  RtcpDemuxer demuxer;
+
+  const std::string rsid = "a";
+  constexpr uint32_t ssrc = 404;
+  MockRtcpPacketSink sink;
+  demuxer.AddSink(rsid, &sink);
+
+  // Removal before resolution.
+  demuxer.RemoveSink(&sink);
+  demuxer.OnRsidResolved(rsid, ssrc);
+
+  // The removed sink does not get callbacks.
+  auto packet = CreateRtcpPacket(ssrc);
+  auto array_view = GetArrayView(packet);
+  EXPECT_CALL(sink, OnRtcpPacket(_)).Times(0);  // Not called.
+  demuxer.OnRtcpPacket(array_view);
+}
+
+TEST(RtcpDemuxerTest, NoCallbackOnRsidSinkRemovedAfterRsidResolution) {
+  RtcpDemuxer demuxer;
+
+  const std::string rsid = "a";
+  constexpr uint32_t ssrc = 404;
+  MockRtcpPacketSink sink;
+  demuxer.AddSink(rsid, &sink);
+
+  // Removal after resolution.
+  demuxer.OnRsidResolved(rsid, ssrc);
+  demuxer.RemoveSink(&sink);
+
+  // The removed sink does not get callbacks.
+  auto packet = CreateRtcpPacket(ssrc);
+  auto array_view = GetArrayView(packet);
+  EXPECT_CALL(sink, OnRtcpPacket(_)).Times(0);  // Not called.
+  demuxer.OnRtcpPacket(array_view);
+}
+
+TEST(RtcpDemuxerTest, NoCallbackOnBroadcastSinkRemovedBeforeFirstPacket) {
+  RtcpDemuxer demuxer;
+
+  MockRtcpPacketSink sink;
+  demuxer.AddBroadcastSink(&sink);
+
+  demuxer.RemoveBroadcastSink(&sink);
+
+  // The removed sink does not get callbacks.
+  constexpr uint32_t ssrc = 404;
+  auto packet = CreateRtcpPacket(ssrc);
+  auto array_view = GetArrayView(packet);
+  EXPECT_CALL(sink, OnRtcpPacket(_)).Times(0);  // Not called.
+  demuxer.OnRtcpPacket(array_view);
+}
+
+TEST(RtcpDemuxerTest, NoCallbackOnBroadcastSinkRemovedAfterFirstPacket) {
+  RtcpDemuxer demuxer;
+
+  NiceMock<MockRtcpPacketSink> sink;
+  demuxer.AddBroadcastSink(&sink);
+
+  constexpr uint32_t ssrc = 404;
+  auto before_packet = CreateRtcpPacket(ssrc);
+  auto before_array_view = GetArrayView(before_packet);
+  demuxer.OnRtcpPacket(before_array_view);
+
+  demuxer.RemoveBroadcastSink(&sink);
+
+  // The removed sink does not get callbacks.
+  auto after_packet = CreateRtcpPacket(ssrc);
+  auto after_array_view = GetArrayView(after_packet);
+  EXPECT_CALL(sink, OnRtcpPacket(_)).Times(0);  // Not called.
+  demuxer.OnRtcpPacket(after_array_view);
+}
+
+// The RSID to SSRC mapping should be one-to-one. If we end up receiving
+// two (or more) packets with the same SSRC, but different RSIDs, we guarantee
+// remembering the first one; no guarantees are made about further associations.
+TEST(RtcpDemuxerTest, FirstRsolutionOfRsidNotForgotten) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+
+  const std::string rsid = "a";
+  demuxer.AddSink(rsid, &sink);
+
+  constexpr uint32_t ssrc_a = 111;  // First resolution - guaranteed effective.
+  demuxer.OnRsidResolved(rsid, ssrc_a);
+
+  constexpr uint32_t ssrc_b = 222;  // Second resolution - no guarantees.
+  demuxer.OnRsidResolved(rsid, ssrc_b);
+
+  auto packet_a = CreateRtcpPacket(ssrc_a);
+  auto array_view_a = GetArrayView(packet_a);
+  EXPECT_CALL(sink, OnRtcpPacket(array_view_a)).Times(1);
+  demuxer.OnRtcpPacket(array_view_a);
+
+  auto packet_b = CreateRtcpPacket(ssrc_b);
+  auto array_view_b = GetArrayView(packet_b);
+  EXPECT_CALL(sink, OnRtcpPacket(array_view_b)).Times(AtLeast(0));
+  demuxer.OnRtcpPacket(array_view_b);
+
+  // Test tear-down
+  demuxer.RemoveSink(&sink);
+}
+
+#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
+TEST(RtcpDemuxerTest, RepeatedSsrcToSinkAssociationsDisallowed) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+
+  constexpr uint32_t ssrc = 101;
+  demuxer.AddSink(ssrc, &sink);
+  EXPECT_DEATH(demuxer.AddSink(ssrc, &sink), "");
+
+  // Test tear-down
+  demuxer.RemoveSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, RepeatedRsidToSinkAssociationsDisallowed) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+
+  const std::string rsid = "z";
+  demuxer.AddSink(rsid, &sink);
+  EXPECT_DEATH(demuxer.AddSink(rsid, &sink), "");
+
+  // Test tear-down
+  demuxer.RemoveSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, RepeatedBroadcastSinkRegistrationDisallowed) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+
+  demuxer.AddBroadcastSink(&sink);
+  EXPECT_DEATH(demuxer.AddBroadcastSink(&sink), "");
+
+  // Test tear-down
+  demuxer.RemoveBroadcastSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, SsrcSinkCannotAlsoBeRegisteredAsBroadcast) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+
+  constexpr uint32_t ssrc = 101;
+  demuxer.AddSink(ssrc, &sink);
+  EXPECT_DEATH(demuxer.AddBroadcastSink(&sink), "");
+
+  // Test tear-down
+  demuxer.RemoveSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, RsidSinkCannotAlsoBeRegisteredAsBroadcast) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+
+  const std::string rsid = "z";
+  demuxer.AddSink(rsid, &sink);
+  EXPECT_DEATH(demuxer.AddBroadcastSink(&sink), "");
+
+  // Test tear-down
+  demuxer.RemoveSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, BroadcastSinkCannotAlsoBeRegisteredAsSsrcSink) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+
+  demuxer.AddBroadcastSink(&sink);
+  constexpr uint32_t ssrc = 101;
+  EXPECT_DEATH(demuxer.AddSink(ssrc, &sink), "");
+
+  // Test tear-down
+  demuxer.RemoveBroadcastSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, BroadcastSinkCannotAlsoBeRegisteredAsRsidSink) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+
+  demuxer.AddBroadcastSink(&sink);
+  const std::string rsid = "j";
+  EXPECT_DEATH(demuxer.AddSink(rsid, &sink), "");
+
+  // Test tear-down
+  demuxer.RemoveBroadcastSink(&sink);
+}
+
+TEST(RtcpDemuxerTest, MayNotCallRemoveSinkOnNeverAddedSink) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+
+  EXPECT_DEATH(demuxer.RemoveSink(&sink), "");
+}
+
+TEST(RtcpDemuxerTest, MayNotCallRemoveBroadcastSinkOnNeverAddedSink) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+
+  EXPECT_DEATH(demuxer.RemoveBroadcastSink(&sink), "");
+}
+
+TEST(RtcpDemuxerTest, RsidMustBeNonEmpty) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+  EXPECT_DEATH(demuxer.AddSink("", &sink), "");
+}
+
+TEST(RtcpDemuxerTest, RsidMustBeAlphaNumeric) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+  EXPECT_DEATH(demuxer.AddSink("a_3", &sink), "");
+}
+
+TEST(RtcpDemuxerTest, RsidMustNotExceedMaximumLength) {
+  RtcpDemuxer demuxer;
+  MockRtcpPacketSink sink;
+  std::string rsid(StreamId::kMaxSize + 1, 'a');
+  EXPECT_DEATH(demuxer.AddSink(rsid, &sink), "");
+}
+#endif
+}  // namespace webrtc