src/media/cast/rtcp/rtcp_receiver_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "media/cast/rtcp/mock_rtcp_receiver_feedback.h"
   7 #include "media/cast/rtcp/mock_rtcp_sender_feedback.h"
   8 #include "media/cast/rtcp/rtcp_receiver.h"
   9 #include "media/cast/rtcp/rtcp_utility.h"
  10 #include "media/cast/rtcp/test_rtcp_packet_builder.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12
  13 namespace media {
  14 namespace cast {
  15
  16 using testing::_;
  17
  18 static const uint32 kSenderSsrc = 0x10203;
  19 static const uint32 kSourceSsrc = 0x40506;
  20 static const uint32 kUnknownSsrc = 0xDEAD;
  21 static const std::string kCName("test@10.1.1.1");
  22
  23 class SenderFeedbackCastVerification : public RtcpSenderFeedback {
  24  public:
  25   SenderFeedbackCastVerification() : called_(false) {}
  26   virtual void OnReceivedReportBlock(
  27       const RtcpReportBlock& report_block) OVERRIDE {};
  28   virtual void OnReceivedIntraFrameRequest() OVERRIDE {};
  29   virtual void OnReceivedRpsi(uint8 payload_type,
  30                               uint64 picture_id) OVERRIDE {};
  31   virtual void OnReceivedRemb(uint32 bitrate) OVERRIDE {};
  32   virtual void OnReceivedNackRequest(
  33       const std::list<uint16>& nack_sequence_numbers) OVERRIDE {};
  34
  35   virtual void OnReceivedCastFeedback(
  36       const RtcpCastMessage& cast_feedback) OVERRIDE {
  37     EXPECT_EQ(cast_feedback.media_ssrc_, kSenderSsrc);
  38     EXPECT_EQ(cast_feedback.ack_frame_id_, kAckFrameId);
  39
  40     MissingFramesAndPacketsMap::const_iterator frame_it =
  41         cast_feedback.missing_frames_and_packets_.begin();
  42
  43     EXPECT_TRUE(frame_it != cast_feedback.missing_frames_and_packets_.end());
  44     EXPECT_EQ(kLostFrameId, frame_it->first);
  45     EXPECT_TRUE(frame_it->second.empty());
  46     ++frame_it;
  47     EXPECT_TRUE(frame_it != cast_feedback.missing_frames_and_packets_.end());
  48     EXPECT_EQ(kFrameIdWithLostPackets, frame_it->first);
  49     EXPECT_EQ(3UL, frame_it->second.size());
  50     PacketIdSet::const_iterator packet_it = frame_it->second.begin();
  51     EXPECT_EQ(kLostPacketId1, *packet_it);
  52     ++packet_it;
  53     EXPECT_EQ(kLostPacketId2, *packet_it);
  54     ++packet_it;
  55     EXPECT_EQ(kLostPacketId3, *packet_it);
  56     ++frame_it;
  57     EXPECT_EQ(frame_it, cast_feedback.missing_frames_and_packets_.end());
  58     called_ = true;
  59   }
  60
  61   bool called() { return called_; }
  62
  63  private:
  64   bool called_;
  65 };
  66
  67
  68 class RtcpReceiverTest : public ::testing::Test {
  69  protected:
  70   RtcpReceiverTest()
  71       : rtcp_receiver_(new RtcpReceiver(&mock_sender_feedback_,
  72                                         &mock_receiver_feedback_,
  73                                         &mock_rtt_feedback_,
  74                                         kSourceSsrc)) {
  75   }
  76
  77   virtual ~RtcpReceiverTest() {}
  78
  79   virtual void SetUp() OVERRIDE {
  80     EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0);
  81     EXPECT_CALL(mock_receiver_feedback_,
  82                 OnReceiverReferenceTimeReport(_)).Times(0);
  83     EXPECT_CALL(mock_receiver_feedback_,
  84                 OnReceivedSendReportRequest()).Times(0);
  85
  86     EXPECT_CALL(mock_sender_feedback_, OnReceivedReportBlock(_)).Times(0);
  87     EXPECT_CALL(mock_sender_feedback_, OnReceivedIntraFrameRequest()).Times(0);
  88     EXPECT_CALL(mock_sender_feedback_, OnReceivedRpsi(_, _)).Times(0);
  89     EXPECT_CALL(mock_sender_feedback_, OnReceivedRemb(_)).Times(0);
  90     EXPECT_CALL(mock_sender_feedback_, OnReceivedNackRequest(_)).Times(0);
  91     EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(0);
  92
  93     EXPECT_CALL(mock_rtt_feedback_,
  94                 OnReceivedDelaySinceLastReport(_, _, _)).Times(0);
  95
  96     expected_sender_info_.ntp_seconds = kNtpHigh;
  97     expected_sender_info_.ntp_fraction = kNtpLow;
  98     expected_sender_info_.rtp_timestamp = kRtpTimestamp;
  99     expected_sender_info_.send_packet_count = kSendPacketCount;
 100     expected_sender_info_.send_octet_count = kSendOctetCount;
 101
 102     expected_report_block_.remote_ssrc = kSenderSsrc;
 103     expected_report_block_.media_ssrc = kSourceSsrc;
 104     expected_report_block_.fraction_lost = kLoss >> 24;
 105     expected_report_block_.cumulative_lost = kLoss & 0xffffff;
 106     expected_report_block_.extended_high_sequence_number = kExtendedMax;
 107     expected_report_block_.jitter = kJitter;
 108     expected_report_block_.last_sr = kLastSr;
 109     expected_report_block_.delay_since_last_sr = kDelayLastSr;
 110     expected_receiver_reference_report_.remote_ssrc = kSenderSsrc;
 111     expected_receiver_reference_report_.ntp_seconds = kNtpHigh;
 112     expected_receiver_reference_report_.ntp_fraction = kNtpLow;
 113   }
 114
 115   // Injects an RTCP packet into the receiver.
 116   void InjectRtcpPacket(const uint8* packet, uint16 length) {
 117     RtcpParser rtcp_parser(packet, length);
 118     rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser);
 119   }
 120
 121   MockRtcpReceiverFeedback mock_receiver_feedback_;
 122   MockRtcpRttFeedback mock_rtt_feedback_;
 123   MockRtcpSenderFeedback mock_sender_feedback_;
 124   scoped_ptr<RtcpReceiver> rtcp_receiver_;
 125   RtcpSenderInfo expected_sender_info_;
 126   RtcpReportBlock expected_report_block_;
 127   RtcpReceiverReferenceTimeReport expected_receiver_reference_report_;
 128 };
 129
 130 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) {
 131   const uint8 bad_packet[] = {0, 0, 0, 0};
 132   InjectRtcpPacket(bad_packet, sizeof(bad_packet));
 133 }
 134
 135 TEST_F(RtcpReceiverTest, InjectSenderReportPacket) {
 136   TestRtcpPacketBuilder p;
 137   p.AddSr(kSenderSsrc, 0);
 138
 139   // Expected to be ignored since the sender ssrc does not match our
 140   // remote ssrc.
 141   InjectRtcpPacket(p.Packet(), p.Length());
 142
 143   EXPECT_CALL(mock_receiver_feedback_,
 144               OnReceivedSenderReport(expected_sender_info_)).Times(1);
 145   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 146
 147   // Expected to be pass through since the sender ssrc match our remote ssrc.
 148   InjectRtcpPacket(p.Packet(), p.Length());
 149 }
 150
 151 TEST_F(RtcpReceiverTest, InjectReceiveReportPacket) {
 152   TestRtcpPacketBuilder p1;
 153   p1.AddRr(kSenderSsrc, 1);
 154   p1.AddRb(kUnknownSsrc);
 155
 156   // Expected to be ignored since the source ssrc does not match our
 157   // local ssrc.
 158   InjectRtcpPacket(p1.Packet(), p1.Length());
 159
 160   EXPECT_CALL(mock_sender_feedback_,
 161               OnReceivedReportBlock(expected_report_block_)).Times(1);
 162
 163   EXPECT_CALL(mock_rtt_feedback_,
 164       OnReceivedDelaySinceLastReport(kSourceSsrc,
 165           kLastSr,
 166           kDelayLastSr)).Times(1);
 167
 168   TestRtcpPacketBuilder p2;
 169   p2.AddRr(kSenderSsrc, 1);
 170   p2.AddRb(kSourceSsrc);
 171
 172   // Expected to be pass through since the sender ssrc match our local ssrc.
 173   InjectRtcpPacket(p2.Packet(), p2.Length());
 174 }
 175
 176 TEST_F(RtcpReceiverTest, InjectSenderReportWithReportBlockPacket) {
 177   TestRtcpPacketBuilder p1;
 178   p1.AddSr(kSenderSsrc, 1);
 179   p1.AddRb(kUnknownSsrc);
 180
 181   // Sender report expected to be ignored since the sender ssrc does not match
 182   // our remote ssrc.
 183   // Report block expected to be ignored since the source ssrc does not match
 184   // our local ssrc.
 185   InjectRtcpPacket(p1.Packet(), p1.Length());
 186
 187   EXPECT_CALL(mock_receiver_feedback_,
 188               OnReceivedSenderReport(expected_sender_info_)).Times(1);
 189   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 190
 191   // Sender report expected to be pass through since the sender ssrc match our
 192   // remote ssrc.
 193   // Report block expected to be ignored since the source ssrc does not match
 194   // our local ssrc.
 195   InjectRtcpPacket(p1.Packet(), p1.Length());
 196
 197   EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0);
 198   EXPECT_CALL(mock_sender_feedback_,
 199               OnReceivedReportBlock(expected_report_block_)).Times(1);
 200   EXPECT_CALL(mock_rtt_feedback_,
 201       OnReceivedDelaySinceLastReport(kSourceSsrc,
 202         kLastSr,
 203         kDelayLastSr)).Times(1);
 204
 205   rtcp_receiver_->SetRemoteSSRC(0);
 206
 207   TestRtcpPacketBuilder p2;
 208   p2.AddSr(kSenderSsrc, 1);
 209   p2.AddRb(kSourceSsrc);
 210
 211   // Sender report expected to be ignored since the sender ssrc does not match
 212   // our remote ssrc.
 213   // Receiver report expected to be pass through since the sender ssrc match
 214   // our local ssrc.
 215   InjectRtcpPacket(p2.Packet(), p2.Length());
 216
 217   EXPECT_CALL(mock_receiver_feedback_,
 218               OnReceivedSenderReport(expected_sender_info_)).Times(1);
 219   EXPECT_CALL(mock_sender_feedback_,
 220               OnReceivedReportBlock(expected_report_block_)).Times(1);
 221   EXPECT_CALL(mock_rtt_feedback_,
 222       OnReceivedDelaySinceLastReport(kSourceSsrc,
 223           kLastSr,
 224           kDelayLastSr)).Times(1);
 225
 226   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 227
 228   // Sender report expected to be pass through since the sender ssrc match our
 229   // remote ssrc.
 230   // Receiver report expected to be pass through since the sender ssrc match
 231   // our local ssrc.
 232   InjectRtcpPacket(p2.Packet(), p2.Length());
 233 }
 234
 235 TEST_F(RtcpReceiverTest, InjectSenderReportPacketWithDlrr) {
 236   TestRtcpPacketBuilder p;
 237   p.AddSr(kSenderSsrc, 0);
 238   p.AddXrHeader(kSenderSsrc);
 239   p.AddXrUnknownBlock();
 240   p.AddXrExtendedDlrrBlock(kSenderSsrc);
 241   p.AddXrUnknownBlock();
 242   p.AddSdesCname(kSenderSsrc, kCName);
 243
 244   // Expected to be ignored since the source ssrc does not match our
 245   // local ssrc.
 246   InjectRtcpPacket(p.Packet(), p.Length());
 247
 248   EXPECT_CALL(mock_receiver_feedback_,
 249               OnReceivedSenderReport(expected_sender_info_)).Times(1);
 250   EXPECT_CALL(mock_rtt_feedback_,
 251       OnReceivedDelaySinceLastReport(kSenderSsrc,
 252           kLastSr,
 253           kDelayLastSr)).Times(1);
 254
 255   // Enable receiving sender report.
 256   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 257
 258   // Expected to be pass through since the sender ssrc match our local ssrc.
 259   InjectRtcpPacket(p.Packet(), p.Length());
 260 }
 261
 262 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithRrtr) {
 263   TestRtcpPacketBuilder p1;
 264   p1.AddRr(kSenderSsrc, 1);
 265   p1.AddRb(kUnknownSsrc);
 266   p1.AddXrHeader(kSenderSsrc);
 267   p1.AddXrRrtrBlock();
 268
 269   // Expected to be ignored since the source ssrc does not match our
 270   // local ssrc.
 271   InjectRtcpPacket(p1.Packet(), p1.Length());
 272
 273   EXPECT_CALL(mock_sender_feedback_,
 274               OnReceivedReportBlock(expected_report_block_)).Times(1);
 275   EXPECT_CALL(mock_rtt_feedback_,
 276       OnReceivedDelaySinceLastReport(kSourceSsrc,
 277           kLastSr,
 278           kDelayLastSr)).Times(1);
 279   EXPECT_CALL(mock_receiver_feedback_, OnReceiverReferenceTimeReport(
 280       expected_receiver_reference_report_)).Times(1);
 281
 282   // Enable receiving reference time report.
 283   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 284
 285   TestRtcpPacketBuilder p2;
 286   p2.AddRr(kSenderSsrc, 1);
 287   p2.AddRb(kSourceSsrc);
 288   p2.AddXrHeader(kSenderSsrc);
 289   p2.AddXrRrtrBlock();
 290
 291   // Expected to be pass through since the sender ssrc match our local ssrc.
 292   InjectRtcpPacket(p2.Packet(), p2.Length());
 293 }
 294
 295 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithIntraFrameRequest) {
 296   TestRtcpPacketBuilder p1;
 297   p1.AddRr(kSenderSsrc, 1);
 298   p1.AddRb(kUnknownSsrc);
 299   p1.AddPli(kSenderSsrc, kUnknownSsrc);
 300
 301   // Expected to be ignored since the source ssrc does not match our
 302   // local ssrc.
 303   InjectRtcpPacket(p1.Packet(), p1.Length());
 304
 305   EXPECT_CALL(mock_sender_feedback_,
 306               OnReceivedReportBlock(expected_report_block_)).Times(1);
 307   EXPECT_CALL(mock_rtt_feedback_,
 308       OnReceivedDelaySinceLastReport(kSourceSsrc,
 309           kLastSr,
 310           kDelayLastSr)).Times(1);
 311   EXPECT_CALL(mock_sender_feedback_, OnReceivedIntraFrameRequest()).Times(1);
 312
 313   TestRtcpPacketBuilder p2;
 314   p2.AddRr(kSenderSsrc, 1);
 315   p2.AddRb(kSourceSsrc);
 316   p2.AddPli(kSenderSsrc, kSourceSsrc);
 317
 318   // Expected to be pass through since the sender ssrc match our local ssrc.
 319   InjectRtcpPacket(p2.Packet(), p2.Length());
 320 }
 321
 322 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastFeedback) {
 323   TestRtcpPacketBuilder p1;
 324   p1.AddRr(kSenderSsrc, 1);
 325   p1.AddRb(kUnknownSsrc);
 326   p1.AddCast(kSenderSsrc, kUnknownSsrc);
 327
 328   // Expected to be ignored since the source ssrc does not match our
 329   // local ssrc.
 330   InjectRtcpPacket(p1.Packet(), p1.Length());
 331
 332   EXPECT_CALL(mock_sender_feedback_,
 333               OnReceivedReportBlock(expected_report_block_)).Times(1);
 334   EXPECT_CALL(mock_rtt_feedback_,
 335       OnReceivedDelaySinceLastReport(kSourceSsrc,
 336           kLastSr,
 337           kDelayLastSr)).Times(1);
 338   EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(1);
 339
 340   // Enable receiving the cast feedback.
 341   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 342
 343   TestRtcpPacketBuilder p2;
 344   p2.AddRr(kSenderSsrc, 1);
 345   p2.AddRb(kSourceSsrc);
 346   p2.AddCast(kSenderSsrc, kSourceSsrc);
 347
 348   // Expected to be pass through since the sender ssrc match our local ssrc.
 349   InjectRtcpPacket(p2.Packet(), p2.Length());
 350 }
 351
 352 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastVerification) {
 353   SenderFeedbackCastVerification sender_feedback_cast_verification;
 354   RtcpReceiver rtcp_receiver(&sender_feedback_cast_verification,
 355                              &mock_receiver_feedback_,
 356                              &mock_rtt_feedback_,
 357                              kSourceSsrc);
 358
 359   EXPECT_CALL(mock_rtt_feedback_,
 360       OnReceivedDelaySinceLastReport(kSourceSsrc,
 361           kLastSr,
 362           kDelayLastSr)).Times(1);
 363
 364   // Enable receiving the cast feedback.
 365   rtcp_receiver.SetRemoteSSRC(kSenderSsrc);
 366
 367   TestRtcpPacketBuilder p;
 368   p.AddRr(kSenderSsrc, 1);
 369   p.AddRb(kSourceSsrc);
 370   p.AddCast(kSenderSsrc, kSourceSsrc);
 371
 372   // Expected to be pass through since the sender ssrc match our local ssrc.
 373   RtcpParser rtcp_parser(p.Packet(), p.Length());
 374   rtcp_receiver.IncomingRtcpPacket(&rtcp_parser);
 375
 376   EXPECT_TRUE(sender_feedback_cast_verification.called());
 377 }
 378
 379 }  // namespace cast
 380 }  // namespace media