src/media/cast/net/rtcp/rtcp_receiver_unittest.cc

   1 // Copyright 2014 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 "base/test/simple_test_tick_clock.h"
   7 #include "media/cast/cast_environment.h"
   8 #include "media/cast/net/cast_transport_defines.h"
   9 #include "media/cast/net/rtcp/mock_rtcp_receiver_feedback.h"
  10 #include "media/cast/net/rtcp/rtcp_receiver.h"
  11 #include "media/cast/net/rtcp/rtcp_utility.h"
  12 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h"
  13 #include "media/cast/test/fake_single_thread_task_runner.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15
  16 namespace media {
  17 namespace cast {
  18
  19 using testing::_;
  20
  21 static const uint32 kSenderSsrc = 0x10203;
  22 static const uint32 kSourceSsrc = 0x40506;
  23 static const uint32 kUnknownSsrc = 0xDEAD;
  24 static const base::TimeDelta kTargetDelay =
  25     base::TimeDelta::FromMilliseconds(100);
  26
  27 namespace {
  28
  29 class RtcpMessageVerification : public MockRtcpReceiverFeedback {
  30  public:
  31   RtcpMessageVerification()
  32       : called_on_received_sender_log_(false),
  33         called_on_received_receiver_log_(false),
  34         called_on_received_cast_message_(false) {}
  35
  36   virtual void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log)
  37       OVERRIDE {
  38     EXPECT_EQ(expected_receiver_log_.size(), receiver_log.size());
  39     RtcpReceiverLogMessage::const_iterator expected_it =
  40         expected_receiver_log_.begin();
  41     RtcpReceiverLogMessage::const_iterator incoming_it = receiver_log.begin();
  42     for (; incoming_it != receiver_log.end(); ++incoming_it) {
  43       EXPECT_EQ(expected_it->rtp_timestamp_, incoming_it->rtp_timestamp_);
  44       EXPECT_EQ(expected_it->event_log_messages_.size(),
  45                 incoming_it->event_log_messages_.size());
  46
  47       RtcpReceiverEventLogMessages::const_iterator event_incoming_it =
  48           incoming_it->event_log_messages_.begin();
  49       RtcpReceiverEventLogMessages::const_iterator event_expected_it =
  50           expected_it->event_log_messages_.begin();
  51       for (; event_incoming_it != incoming_it->event_log_messages_.end();
  52            ++event_incoming_it, ++event_expected_it) {
  53         EXPECT_EQ(event_expected_it->type, event_incoming_it->type);
  54         EXPECT_EQ(event_expected_it->event_timestamp,
  55                   event_incoming_it->event_timestamp);
  56         if (event_expected_it->type == PACKET_RECEIVED) {
  57           EXPECT_EQ(event_expected_it->packet_id, event_incoming_it->packet_id);
  58         } else {
  59           EXPECT_EQ(event_expected_it->delay_delta,
  60                     event_incoming_it->delay_delta);
  61         }
  62       }
  63       expected_receiver_log_.pop_front();
  64       expected_it = expected_receiver_log_.begin();
  65     }
  66     called_on_received_receiver_log_ = true;
  67   }
  68
  69   virtual void OnReceivedCastFeedback(const RtcpCastMessage& cast_message)
  70       OVERRIDE {
  71     EXPECT_EQ(cast_message.media_ssrc, kSenderSsrc);
  72     EXPECT_EQ(cast_message.ack_frame_id, kAckFrameId);
  73
  74     MissingFramesAndPacketsMap::const_iterator frame_it =
  75         cast_message.missing_frames_and_packets.begin();
  76
  77     EXPECT_TRUE(frame_it != cast_message.missing_frames_and_packets.end());
  78     EXPECT_EQ(kLostFrameId, frame_it->first);
  79     EXPECT_EQ(frame_it->second.size(), 1UL);
  80     EXPECT_EQ(*frame_it->second.begin(), kRtcpCastAllPacketsLost);
  81     ++frame_it;
  82     EXPECT_TRUE(frame_it != cast_message.missing_frames_and_packets.end());
  83     EXPECT_EQ(kFrameIdWithLostPackets, frame_it->first);
  84     EXPECT_EQ(3UL, frame_it->second.size());
  85     PacketIdSet::const_iterator packet_it = frame_it->second.begin();
  86     EXPECT_EQ(kLostPacketId1, *packet_it);
  87     ++packet_it;
  88     EXPECT_EQ(kLostPacketId2, *packet_it);
  89     ++packet_it;
  90     EXPECT_EQ(kLostPacketId3, *packet_it);
  91     ++frame_it;
  92     EXPECT_TRUE(frame_it == cast_message.missing_frames_and_packets.end());
  93     called_on_received_cast_message_ = true;
  94   }
  95
  96   bool OnReceivedReceiverLogCalled() const {
  97     return called_on_received_receiver_log_ && expected_receiver_log_.empty();
  98   }
  99
 100   bool OnReceivedCastFeedbackCalled() const {
 101     return called_on_received_cast_message_;
 102   }
 103
 104   void SetExpectedReceiverLog(const RtcpReceiverLogMessage& receiver_log) {
 105     expected_receiver_log_ = receiver_log;
 106   }
 107
 108  private:
 109   RtcpReceiverLogMessage expected_receiver_log_;
 110   bool called_on_received_sender_log_;
 111   bool called_on_received_receiver_log_;
 112   bool called_on_received_cast_message_;
 113
 114   DISALLOW_COPY_AND_ASSIGN(RtcpMessageVerification);
 115 };
 116
 117 }  // namespace
 118
 119 class RtcpReceiverTest : public ::testing::Test {
 120  protected:
 121   RtcpReceiverTest()
 122       : testing_clock_(new base::SimpleTestTickClock()),
 123         task_runner_(new test::FakeSingleThreadTaskRunner(
 124             testing_clock_.get())),
 125         rtcp_receiver_(new RtcpReceiver(&mock_receiver_feedback_,
 126                                         kSourceSsrc)) {
 127     EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0);
 128     EXPECT_CALL(mock_receiver_feedback_, OnReceiverReferenceTimeReport(_))
 129         .Times(0);
 130     EXPECT_CALL(mock_receiver_feedback_, OnReceivedCastFeedback(_)).Times(0);
 131     EXPECT_CALL(mock_receiver_feedback_, OnReceivedDelaySinceLastReport(_, _))
 132         .Times(0);
 133
 134     expected_sender_info_.ntp_seconds = kNtpHigh;
 135     expected_sender_info_.ntp_fraction = kNtpLow;
 136     expected_sender_info_.rtp_timestamp = kRtpTimestamp;
 137     expected_sender_info_.send_packet_count = kSendPacketCount;
 138     expected_sender_info_.send_octet_count = kSendOctetCount;
 139
 140     expected_report_block_.remote_ssrc = kSenderSsrc;
 141     expected_report_block_.media_ssrc = kSourceSsrc;
 142     expected_report_block_.fraction_lost = kLoss >> 24;
 143     expected_report_block_.cumulative_lost = kLoss & 0xffffff;
 144     expected_report_block_.extended_high_sequence_number = kExtendedMax;
 145     expected_report_block_.jitter = kTestJitter;
 146     expected_report_block_.last_sr = kLastSr;
 147     expected_report_block_.delay_since_last_sr = kDelayLastSr;
 148     expected_receiver_reference_report_.remote_ssrc = kSenderSsrc;
 149     expected_receiver_reference_report_.ntp_seconds = kNtpHigh;
 150     expected_receiver_reference_report_.ntp_fraction = kNtpLow;
 151   }
 152
 153   virtual ~RtcpReceiverTest() {}
 154
 155   // Injects an RTCP packet into the receiver.
 156   void InjectRtcpPacket(const uint8* packet, uint16 length) {
 157     RtcpParser rtcp_parser(packet, length);
 158     rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser);
 159   }
 160
 161   scoped_ptr<base::SimpleTestTickClock> testing_clock_;
 162   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
 163   MockRtcpReceiverFeedback mock_receiver_feedback_;
 164   scoped_ptr<RtcpReceiver> rtcp_receiver_;
 165   RtcpSenderInfo expected_sender_info_;
 166   RtcpReportBlock expected_report_block_;
 167   RtcpReceiverReferenceTimeReport expected_receiver_reference_report_;
 168
 169   DISALLOW_COPY_AND_ASSIGN(RtcpReceiverTest);
 170 };
 171
 172 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) {
 173   const uint8 bad_packet[] = {0, 0, 0, 0};
 174   InjectRtcpPacket(bad_packet, sizeof(bad_packet));
 175 }
 176
 177 TEST_F(RtcpReceiverTest, InjectSenderReportPacket) {
 178   TestRtcpPacketBuilder p;
 179   p.AddSr(kSenderSsrc, 0);
 180
 181   // Expected to be ignored since the sender ssrc does not match our
 182   // remote ssrc.
 183   InjectRtcpPacket(p.Data(), p.Length());
 184
 185   EXPECT_CALL(mock_receiver_feedback_,
 186               OnReceivedSenderReport(expected_sender_info_)).Times(1);
 187   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 188
 189   // Expected to be pass through since the sender ssrc match our remote ssrc.
 190   InjectRtcpPacket(p.Data(), p.Length());
 191 }
 192
 193 TEST_F(RtcpReceiverTest, InjectReceiveReportPacket) {
 194   TestRtcpPacketBuilder p1;
 195   p1.AddRr(kSenderSsrc, 1);
 196   p1.AddRb(kUnknownSsrc);
 197
 198   // Expected to be ignored since the source ssrc does not match our
 199   // local ssrc.
 200   InjectRtcpPacket(p1.Data(), p1.Length());
 201
 202   EXPECT_CALL(mock_receiver_feedback_,
 203               OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
 204
 205   TestRtcpPacketBuilder p2;
 206   p2.AddRr(kSenderSsrc, 1);
 207   p2.AddRb(kSourceSsrc);
 208
 209   // Expected to be pass through since the sender ssrc match our local ssrc.
 210   InjectRtcpPacket(p2.Data(), p2.Length());
 211 }
 212
 213 TEST_F(RtcpReceiverTest, InjectSenderReportWithReportBlockPacket) {
 214   TestRtcpPacketBuilder p1;
 215   p1.AddSr(kSenderSsrc, 1);
 216   p1.AddRb(kUnknownSsrc);
 217
 218   // Sender report expected to be ignored since the sender ssrc does not match
 219   // our remote ssrc.
 220   // Report block expected to be ignored since the source ssrc does not match
 221   // our local ssrc.
 222   InjectRtcpPacket(p1.Data(), p1.Length());
 223
 224   EXPECT_CALL(mock_receiver_feedback_,
 225               OnReceivedSenderReport(expected_sender_info_)).Times(1);
 226   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 227
 228   // Sender report expected to be pass through since the sender ssrc match our
 229   // remote ssrc.
 230   // Report block expected to be ignored since the source ssrc does not match
 231   // our local ssrc.
 232   InjectRtcpPacket(p1.Data(), p1.Length());
 233
 234   EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0);
 235   EXPECT_CALL(mock_receiver_feedback_,
 236               OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
 237
 238   rtcp_receiver_->SetRemoteSSRC(0);
 239
 240   TestRtcpPacketBuilder p2;
 241   p2.AddSr(kSenderSsrc, 1);
 242   p2.AddRb(kSourceSsrc);
 243
 244   // Sender report expected to be ignored since the sender ssrc does not match
 245   // our remote ssrc.
 246   // Receiver report expected to be pass through since the sender ssrc match
 247   // our local ssrc.
 248   InjectRtcpPacket(p2.Data(), p2.Length());
 249
 250   EXPECT_CALL(mock_receiver_feedback_,
 251               OnReceivedSenderReport(expected_sender_info_)).Times(1);
 252   EXPECT_CALL(mock_receiver_feedback_,
 253               OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
 254
 255   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 256
 257   // Sender report expected to be pass through since the sender ssrc match our
 258   // remote ssrc.
 259   // Receiver report expected to be pass through since the sender ssrc match
 260   // our local ssrc.
 261   InjectRtcpPacket(p2.Data(), p2.Length());
 262 }
 263
 264 TEST_F(RtcpReceiverTest, InjectSenderReportPacketWithDlrr) {
 265   TestRtcpPacketBuilder p;
 266   p.AddSr(kSenderSsrc, 0);
 267   p.AddXrHeader(kSenderSsrc);
 268   p.AddXrUnknownBlock();
 269   p.AddXrExtendedDlrrBlock(kSenderSsrc);
 270   p.AddXrUnknownBlock();
 271
 272   // Expected to be ignored since the source ssrc does not match our
 273   // local ssrc.
 274   InjectRtcpPacket(p.Data(), p.Length());
 275
 276   EXPECT_CALL(mock_receiver_feedback_,
 277               OnReceivedSenderReport(expected_sender_info_)).Times(1);
 278   EXPECT_CALL(mock_receiver_feedback_,
 279               OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
 280
 281   // Enable receiving sender report.
 282   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 283
 284   // Expected to be pass through since the sender ssrc match our local ssrc.
 285   InjectRtcpPacket(p.Data(), p.Length());
 286 }
 287
 288 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithRrtr) {
 289   TestRtcpPacketBuilder p1;
 290   p1.AddRr(kSenderSsrc, 1);
 291   p1.AddRb(kUnknownSsrc);
 292   p1.AddXrHeader(kSenderSsrc);
 293   p1.AddXrRrtrBlock();
 294
 295   // Expected to be ignored since the source ssrc does not match our
 296   // local ssrc.
 297   InjectRtcpPacket(p1.Data(), p1.Length());
 298
 299   EXPECT_CALL(mock_receiver_feedback_,
 300               OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
 301   EXPECT_CALL(mock_receiver_feedback_,
 302               OnReceiverReferenceTimeReport(
 303                   expected_receiver_reference_report_)).Times(1);
 304
 305   // Enable receiving reference time report.
 306   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 307
 308   TestRtcpPacketBuilder p2;
 309   p2.AddRr(kSenderSsrc, 1);
 310   p2.AddRb(kSourceSsrc);
 311   p2.AddXrHeader(kSenderSsrc);
 312   p2.AddXrRrtrBlock();
 313
 314   // Expected to be pass through since the sender ssrc match our local ssrc.
 315   InjectRtcpPacket(p2.Data(), p2.Length());
 316 }
 317
 318 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithIntraFrameRequest) {
 319   TestRtcpPacketBuilder p1;
 320   p1.AddRr(kSenderSsrc, 1);
 321   p1.AddRb(kUnknownSsrc);
 322
 323   // Expected to be ignored since the source ssrc does not match our
 324   // local ssrc.
 325   InjectRtcpPacket(p1.Data(), p1.Length());
 326
 327   EXPECT_CALL(mock_receiver_feedback_,
 328               OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
 329
 330   TestRtcpPacketBuilder p2;
 331   p2.AddRr(kSenderSsrc, 1);
 332   p2.AddRb(kSourceSsrc);
 333
 334   // Expected to be pass through since the sender ssrc match our local ssrc.
 335   InjectRtcpPacket(p2.Data(), p2.Length());
 336 }
 337
 338 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastFeedback) {
 339   TestRtcpPacketBuilder p1;
 340   p1.AddRr(kSenderSsrc, 1);
 341   p1.AddRb(kUnknownSsrc);
 342   p1.AddCast(kSenderSsrc, kUnknownSsrc, kTargetDelay);
 343
 344   // Expected to be ignored since the source ssrc does not match our
 345   // local ssrc.
 346   InjectRtcpPacket(p1.Data(), p1.Length());
 347
 348   EXPECT_CALL(mock_receiver_feedback_,
 349               OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
 350   EXPECT_CALL(mock_receiver_feedback_, OnReceivedCastFeedback(_)).Times(1);
 351
 352   // Enable receiving the cast feedback.
 353   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
 354
 355   TestRtcpPacketBuilder p2;
 356   p2.AddRr(kSenderSsrc, 1);
 357   p2.AddRb(kSourceSsrc);
 358   p2.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay);
 359
 360   // Expected to be pass through since the sender ssrc match our local ssrc.
 361   InjectRtcpPacket(p2.Data(), p2.Length());
 362 }
 363
 364 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastVerification) {
 365   RtcpMessageVerification verification;
 366   RtcpReceiver rtcp_receiver(&verification, kSourceSsrc);
 367
 368   EXPECT_CALL(verification,
 369               OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
 370
 371   // Enable receiving the cast feedback.
 372   rtcp_receiver.SetRemoteSSRC(kSenderSsrc);
 373
 374   TestRtcpPacketBuilder p;
 375   p.AddRr(kSenderSsrc, 1);
 376   p.AddRb(kSourceSsrc);
 377   p.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay);
 378
 379   // Expected to be pass through since the sender ssrc match our local ssrc.
 380   RtcpParser rtcp_parser(p.Data(), p.Length());
 381   rtcp_receiver.IncomingRtcpPacket(&rtcp_parser);
 382
 383   EXPECT_TRUE(verification.OnReceivedCastFeedbackCalled());
 384 }
 385
 386 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationBase) {
 387   static const uint32 kTimeBaseMs = 12345678;
 388   static const uint32 kTimeDelayMs = 10;
 389   static const uint32 kDelayDeltaMs = 123;
 390   base::SimpleTestTickClock testing_clock;
 391   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 392
 393   RtcpMessageVerification verification;
 394   RtcpReceiver rtcp_receiver(&verification,
 395                              kSourceSsrc);
 396   rtcp_receiver.SetRemoteSSRC(kSenderSsrc);
 397   rtcp_receiver.SetCastReceiverEventHistorySize(100);
 398
 399   RtcpReceiverLogMessage receiver_log;
 400   RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp);
 401   RtcpReceiverEventLogMessage event_log;
 402
 403   event_log.type = FRAME_ACK_SENT;
 404   event_log.event_timestamp = testing_clock.NowTicks();
 405   event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs);
 406   frame_log.event_log_messages_.push_back(event_log);
 407
 408   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 409   event_log.type = PACKET_RECEIVED;
 410   event_log.event_timestamp = testing_clock.NowTicks();
 411   event_log.packet_id = kLostPacketId1;
 412   frame_log.event_log_messages_.push_back(event_log);
 413
 414   event_log.type = PACKET_RECEIVED;
 415   event_log.event_timestamp = testing_clock.NowTicks();
 416   event_log.packet_id = kLostPacketId2;
 417   frame_log.event_log_messages_.push_back(event_log);
 418
 419   receiver_log.push_back(frame_log);
 420
 421   verification.SetExpectedReceiverLog(receiver_log);
 422
 423   TestRtcpPacketBuilder p;
 424   p.AddRr(kSenderSsrc, 1);
 425   p.AddRb(kSourceSsrc);
 426   p.AddReceiverLog(kSenderSsrc);
 427   p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs);
 428   p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0);
 429   p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
 430   p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs);
 431
 432   // Adds duplicated receiver event.
 433   p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs);
 434   p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0);
 435   p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
 436   p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs);
 437
 438   EXPECT_CALL(verification,
 439               OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
 440
 441   RtcpParser rtcp_parser(p.Data(), p.Length());
 442   rtcp_receiver.IncomingRtcpPacket(&rtcp_parser);
 443
 444   EXPECT_TRUE(verification.OnReceivedReceiverLogCalled());
 445 }
 446
 447 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationMulti) {
 448   static const uint32 kTimeBaseMs = 12345678;
 449   static const uint32 kTimeDelayMs = 10;
 450   static const uint32 kDelayDeltaMs = 123;
 451   base::SimpleTestTickClock testing_clock;
 452   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 453
 454   RtcpMessageVerification verification;
 455   RtcpReceiver rtcp_receiver(&verification,
 456                              kSourceSsrc);
 457   rtcp_receiver.SetRemoteSSRC(kSenderSsrc);
 458
 459   RtcpReceiverLogMessage receiver_log;
 460
 461   for (int j = 0; j < 100; ++j) {
 462     RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp);
 463     RtcpReceiverEventLogMessage event_log;
 464     event_log.type = FRAME_ACK_SENT;
 465     event_log.event_timestamp = testing_clock.NowTicks();
 466     event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs);
 467     frame_log.event_log_messages_.push_back(event_log);
 468     receiver_log.push_back(frame_log);
 469     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 470   }
 471
 472   verification.SetExpectedReceiverLog(receiver_log);
 473
 474   TestRtcpPacketBuilder p;
 475   p.AddRr(kSenderSsrc, 1);
 476   p.AddRb(kSourceSsrc);
 477   p.AddReceiverLog(kSenderSsrc);
 478   for (int i = 0; i < 100; ++i) {
 479     p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs + i * kTimeDelayMs);
 480     p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0);
 481   }
 482
 483   EXPECT_CALL(verification,
 484               OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
 485
 486   RtcpParser rtcp_parser(p.Data(), p.Length());
 487   rtcp_receiver.IncomingRtcpPacket(&rtcp_parser);
 488
 489   EXPECT_TRUE(verification.OnReceivedReceiverLogCalled());
 490 }
 491
 492 }  // namespace cast
 493 }  // namespace media