Cast: Re-factor rtcp_sender.cc into rtcp_builder.cc and do some cleanup

media/cast/net/rtcp/rtcp_builder_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/net/cast_transport_defines.h"
 #include "media/cast/net/pacing/paced_sender.h"
 #include "media/cast/net/rtcp/receiver_rtcp_event_subscriber.h"
-#include "media/cast/net/rtcp/rtcp_sender.h"
+#include "media/cast/net/rtcp/rtcp_builder.h"
 #include "media/cast/net/rtcp/rtcp_utility.h"
 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 static const uint32 kSendingSsrc = 0x12345678;
@@ skipping 10 matching lines @@
   report_block.cumulative_lost = kLoss;  // 24 bits valid.
   report_block.extended_high_sequence_number = kExtendedMax;
   report_block.jitter = kTestJitter;
   report_block.last_sr = kLastSr;
   report_block.delay_since_last_sr = kDelayLastSr;
   return report_block;
 }
 
 }  // namespace
 
-class TestRtcpTransport : public PacedPacketSender {
- public:
-  TestRtcpTransport() : packet_count_(0) {}
 
-  virtual bool SendRtcpPacket(uint32 ssrc,
-                              PacketRef packet) OVERRIDE {
-    EXPECT_EQ(expected_packet_.size(), packet->data.size());
-    if (expected_packet_.size() != packet->data.size())
-      return false;
-    EXPECT_EQ(0, memcmp(&expected_packet_[0],
-                        &packet->data[0],
-                        packet->data.size()));
-    packet_count_++;
-    return true;
+class RtcpBuilderTest : public ::testing::Test {
+ protected:
+  RtcpBuilderTest()
+      : testing_clock_(new base::SimpleTestTickClock()),
+        task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
+        rtcp_builder_(new RtcpBuilder(kSendingSsrc)) {}
+
+  void ExpectPacketEQ(scoped_ptr<Packet> golden_packet,
+                      PacketRef packet) {
+    EXPECT_EQ(golden_packet->size(), packet->data.size());
+    if (golden_packet->size() == packet->data.size()) {
+      for (size_t x = 0; x < golden_packet->size(); x++) {
+        EXPECT_EQ((*golden_packet)[x], packet->data[x]);
+        if ((*golden_packet)[x] != packet->data[x])
+          break;
+      }
+    }
   }
 
-  virtual bool SendPackets(
-      const SendPacketVector& packets) OVERRIDE {
-    return false;
-  }
-  virtual bool ResendPackets(
-      const SendPacketVector& packets,
-      const DedupInfo& dedup_info) OVERRIDE {
-    return false;
-  }
+  base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
+  scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;

[miu, 2014/09/03 22:28:07]

Seems like you can get rid of task_runner_ (and its #include).

[hubbe, 2014/09/04 22:21:19]

Done.

+  scoped_ptr<RtcpBuilder> rtcp_builder_;
 
-  virtual void CancelSendingPacket(
-      const PacketKey& packet_key) OVERRIDE {
-  }
-
-  void SetExpectedRtcpPacket(scoped_ptr<Packet> packet) {
-    expected_packet_.swap(*packet);
-  }
-
-  int packet_count() const { return packet_count_; }
-
- private:
-  Packet expected_packet_;
-  int packet_count_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestRtcpTransport);
+  DISALLOW_COPY_AND_ASSIGN(RtcpBuilderTest);
 };
 
-class RtcpSenderTest : public ::testing::Test {
- protected:
-  RtcpSenderTest()
-      : testing_clock_(new base::SimpleTestTickClock()),
-        task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
-        cast_environment_(new CastEnvironment(
-            scoped_ptr<base::TickClock>(testing_clock_).Pass(),
-            task_runner_,
-            task_runner_,
-            task_runner_)),
-        rtcp_sender_(new RtcpSender(&test_transport_, kSendingSsrc)) {}
-
-  base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
-  TestRtcpTransport test_transport_;
-  scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
-  scoped_refptr<CastEnvironment> cast_environment_;
-  scoped_ptr<RtcpSender> rtcp_sender_;
-
-  DISALLOW_COPY_AND_ASSIGN(RtcpSenderTest);
-};
-
-TEST_F(RtcpSenderTest, RtcpReceiverReport) {
+TEST_F(RtcpBuilderTest, RtcpReceiverReport) {
   // Receiver report with report block.
   TestRtcpPacketBuilder p2;
   p2.AddRr(kSendingSsrc, 1);
   p2.AddRb(kMediaSsrc);
-  test_transport_.SetExpectedRtcpPacket(p2.GetPacket().Pass());
 
   RtcpReportBlock report_block = GetReportBlock();
 
-  rtcp_sender_->SendRtcpFromRtpReceiver(
-      &report_block, NULL, NULL, NULL, kDefaultDelay);
-
-  EXPECT_EQ(1, test_transport_.packet_count());
+  ExpectPacketEQ(
+      p2.GetPacket().Pass(),
+      rtcp_builder_->BuildRtcpFromReceiver(
+          &report_block, NULL, NULL, NULL, kDefaultDelay));
 }
 
-TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) {
+TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtr) {
   // Receiver report with report block.
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddXrHeader(kSendingSsrc);
   p.AddXrRrtrBlock();
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
   RtcpReportBlock report_block = GetReportBlock();
 
   RtcpReceiverReferenceTimeReport rrtr;
   rrtr.ntp_seconds = kNtpHigh;
   rrtr.ntp_fraction = kNtpLow;
 
-  rtcp_sender_->SendRtcpFromRtpReceiver(
-      &report_block,
-      &rrtr,
-      NULL,
-      NULL,
-      kDefaultDelay);
-
-  EXPECT_EQ(1, test_transport_.packet_count());
+  ExpectPacketEQ(p.GetPacket().Pass(),
+                 rtcp_builder_->BuildRtcpFromReceiver(
+                     &report_block,
+                     &rrtr,
+                     NULL,
+                     NULL,
+                     kDefaultDelay));
 }
 
-TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) {
+TEST_F(RtcpBuilderTest, RtcpReceiverReportWithCast) {
   // Receiver report with report block.
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
   RtcpReportBlock report_block = GetReportBlock();
 
   RtcpCastMessage cast_message(kMediaSsrc);
   cast_message.ack_frame_id = kAckFrameId;
   PacketIdSet missing_packets;
   cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets;
 
   missing_packets.insert(kLostPacketId1);
   missing_packets.insert(kLostPacketId2);
   missing_packets.insert(kLostPacketId3);
   cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
       missing_packets;
 
-  rtcp_sender_->SendRtcpFromRtpReceiver(
-      &report_block,
-      NULL,
-      &cast_message,
-      NULL,
-      kDefaultDelay);
-
-  EXPECT_EQ(1, test_transport_.packet_count());
+  ExpectPacketEQ(p.GetPacket().Pass(),
+                 rtcp_builder_->BuildRtcpFromReceiver(
+                     &report_block,
+                     NULL,
+                     &cast_message,
+                     NULL,
+                     kDefaultDelay));
 }
 
-TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtraAndCastMessage) {
+TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtraAndCastMessage) {
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddXrHeader(kSendingSsrc);
   p.AddXrRrtrBlock();
   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
   RtcpReportBlock report_block = GetReportBlock();
 
   RtcpReceiverReferenceTimeReport rrtr;
   rrtr.ntp_seconds = kNtpHigh;
   rrtr.ntp_fraction = kNtpLow;
 
   RtcpCastMessage cast_message(kMediaSsrc);
   cast_message.ack_frame_id = kAckFrameId;
   PacketIdSet missing_packets;
   cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets;
 
   missing_packets.insert(kLostPacketId1);
   missing_packets.insert(kLostPacketId2);
   missing_packets.insert(kLostPacketId3);
   cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
       missing_packets;
 
-  rtcp_sender_->SendRtcpFromRtpReceiver(
-      &report_block,
-      &rrtr,
-      &cast_message,
-      NULL,
-      kDefaultDelay);
-
-  EXPECT_EQ(1, test_transport_.packet_count());
+  ExpectPacketEQ(p.GetPacket().Pass(),
+                 rtcp_builder_->BuildRtcpFromReceiver(
+                     &report_block,
+                     &rrtr,
+                     &cast_message,
+                     NULL,
+                     kDefaultDelay));
 }
 
-TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
+TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
   static const uint32 kTimeBaseMs = 12345678;
   static const uint32 kTimeDelayMs = 10;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddXrHeader(kSendingSsrc);
   p.AddXrRrtrBlock();
   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
   RtcpReportBlock report_block = GetReportBlock();
 
   RtcpReceiverReferenceTimeReport rrtr;
   rrtr.ntp_seconds = kNtpHigh;
   rrtr.ntp_fraction = kNtpLow;
 
   RtcpCastMessage cast_message(kMediaSsrc);
   cast_message.ack_frame_id = kAckFrameId;
   PacketIdSet missing_packets;
   cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets;
 
   missing_packets.insert(kLostPacketId1);
   missing_packets.insert(kLostPacketId2);
   missing_packets.insert(kLostPacketId3);
   cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
       missing_packets;
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 
-  rtcp_sender_->SendRtcpFromRtpReceiver(
-      &report_block,
-      &rrtr,
-      &cast_message,
-      &rtcp_events,
-      kDefaultDelay);
+  ExpectPacketEQ(p.GetPacket().Pass(),
+                 rtcp_builder_->BuildRtcpFromReceiver(
+                     &report_block,
+                     &rrtr,
+                     &cast_message,
+                     &rtcp_events,
+                     kDefaultDelay));
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
   p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs);
   p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
   p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
 
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
-
   FrameEvent frame_event;
   frame_event.rtp_timestamp = kRtpTimestamp;
   frame_event.type = FRAME_ACK_SENT;
   frame_event.media_type = VIDEO_EVENT;
   frame_event.timestamp = testing_clock.NowTicks();
   event_subscriber.OnReceiveFrameEvent(frame_event);
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 
   PacketEvent packet_event;
   packet_event.rtp_timestamp = kRtpTimestamp;
   packet_event.type = PACKET_RECEIVED;
   packet_event.media_type = VIDEO_EVENT;
   packet_event.timestamp = testing_clock.NowTicks();
   packet_event.packet_id = kLostPacketId1;
   event_subscriber.OnReceivePacketEvent(packet_event);
   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
   EXPECT_EQ(2u, rtcp_events.size());
 
-  rtcp_sender_->SendRtcpFromRtpReceiver(
-      &report_block,
-      &rrtr,
-      &cast_message,
-      &rtcp_events,
-      kDefaultDelay);
-
-  EXPECT_EQ(2, test_transport_.packet_count());
+  ExpectPacketEQ(
+      p.GetPacket().Pass(),
+      rtcp_builder_->BuildRtcpFromReceiver(
+          &report_block,
+          &rrtr,
+          &cast_message,
+          &rtcp_events,
+          kDefaultDelay));
 }
 
-TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) {
+TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOversizedFrameLog) {
   static const uint32 kTimeBaseMs = 12345678;
   static const uint32 kTimeDelayMs = 10;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
 
   RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
@@ skipping 11 matching lines @@
   p.AddReceiverFrameLog(
       kRtpTimestamp + 2345,
       num_events,
       kTimeBaseMs + (kRtcpMaxReceiverLogMessages - num_events) * kTimeDelayMs);
   for (int i = 0; i < num_events; i++) {
     p.AddReceiverEventLog(
         kLostPacketId1, PACKET_RECEIVED,
         static_cast<uint16>(kTimeDelayMs * i));
   }
 
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   FrameEvent frame_event;
   frame_event.rtp_timestamp = kRtpTimestamp;
   frame_event.type = FRAME_ACK_SENT;
   frame_event.media_type = VIDEO_EVENT;
   frame_event.timestamp = testing_clock.NowTicks();
   event_subscriber.OnReceiveFrameEvent(frame_event);
 
   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
     PacketEvent packet_event;
     packet_event.rtp_timestamp = kRtpTimestamp + 2345;
     packet_event.type = PACKET_RECEIVED;
     packet_event.media_type = VIDEO_EVENT;
     packet_event.timestamp = testing_clock.NowTicks();
     packet_event.packet_id = kLostPacketId1;
     event_subscriber.OnReceivePacketEvent(packet_event);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 
-  rtcp_sender_->SendRtcpFromRtpReceiver(
-      &report_block,
-      NULL,
-      NULL,
-      &rtcp_events,
-      kDefaultDelay);
-
-  EXPECT_EQ(1, test_transport_.packet_count());
+  ExpectPacketEQ(p.GetPacket().Pass(),
+                 rtcp_builder_->BuildRtcpFromReceiver(
+                     &report_block,
+                     NULL,
+                     NULL,
+                     &rtcp_events,
+                     kDefaultDelay));
 }
 
-TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) {
+TEST_F(RtcpBuilderTest, RtcpReceiverReportWithTooManyLogFrames) {
   static const uint32 kTimeBaseMs = 12345678;
   static const uint32 kTimeDelayMs = 10;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
 
   RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
 
   int remaining_bytes = kMaxReceiverLogBytes;
   remaining_bytes -= kRtcpCastLogHeaderSize;
 
   int num_events =
       remaining_bytes / (kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize);
 
   // The last |num_events| events are sent due to receiver log size cap.
   for (size_t i = kRtcpMaxReceiverLogMessages - num_events;
        i < kRtcpMaxReceiverLogMessages;
        ++i) {
     p.AddReceiverFrameLog(kRtpTimestamp + i, 1, kTimeBaseMs + i * kTimeDelayMs);
     p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
   }
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
 
   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
     FrameEvent frame_event;
     frame_event.rtp_timestamp = kRtpTimestamp + static_cast<int>(i);
     frame_event.type = FRAME_ACK_SENT;
     frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 
-  rtcp_sender_->SendRtcpFromRtpReceiver(
-      &report_block,
-      NULL,
-      NULL,
-      &rtcp_events,
-      kDefaultDelay);
-
-  EXPECT_EQ(1, test_transport_.packet_count());
+  ExpectPacketEQ(p.GetPacket().Pass(),
+                 rtcp_builder_->BuildRtcpFromReceiver(
+                     &report_block,
+                     NULL,
+                     NULL,
+                     &rtcp_events,
+                     kDefaultDelay));
 }
 
-TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) {
+TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOldLogFrames) {
   static const uint32 kTimeBaseMs = 12345678;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
 
   RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
 
   // Log 11 events for a single frame, each |kTimeBetweenEventsMs| apart.
   // Only last 10 events will be sent because the first event is more than
   // 4095 milliseconds away from latest event.
   const int kTimeBetweenEventsMs = 410;
   p.AddReceiverFrameLog(kRtpTimestamp, 10, kTimeBaseMs + kTimeBetweenEventsMs);
   for (int i = 0; i < 10; ++i) {
     p.AddReceiverEventLog(0, FRAME_ACK_SENT, i * kTimeBetweenEventsMs);
   }
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   for (int i = 0; i < 11; ++i) {
     FrameEvent frame_event;
     frame_event.rtp_timestamp = kRtpTimestamp;
     frame_event.type = FRAME_ACK_SENT;
     frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
     testing_clock.Advance(
         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 
-  rtcp_sender_->SendRtcpFromRtpReceiver(
-      &report_block,
-      NULL,
-      NULL,
-      &rtcp_events,
-      kDefaultDelay);
-
-  EXPECT_EQ(1, test_transport_.packet_count());
+  ExpectPacketEQ(p.GetPacket().Pass(),
+                 rtcp_builder_->BuildRtcpFromReceiver(
+                     &report_block,
+                     NULL,
+                     NULL,
+                     &rtcp_events,
+                     kDefaultDelay));
 }
 
-TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) {
+TEST_F(RtcpBuilderTest, RtcpReceiverReportRedundancy) {
   uint32 time_base_ms = 12345678;
   int kTimeBetweenEventsMs = 10;
 
   RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms));
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   size_t packet_count = kReceiveLogMessageHistorySize + 10;
@@ skipping 14 matching lines @@
     if (i >= kFirstRedundancyOffset) {
       p.AddReceiverFrameLog(
           kRtpTimestamp,
           1,
           time_base_ms - kFirstRedundancyOffset * kTimeBetweenEventsMs);
       p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
     }
     p.AddReceiverFrameLog(kRtpTimestamp, 1, time_base_ms);
     p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
 
-    test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
-
     FrameEvent frame_event;
     frame_event.rtp_timestamp = kRtpTimestamp;
     frame_event.type = FRAME_ACK_SENT;
     frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
 
     ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
     event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 
-    rtcp_sender_->SendRtcpFromRtpReceiver(
-        &report_block,
-        NULL,
-        NULL,
-        &rtcp_events,
-        kDefaultDelay);
+    ExpectPacketEQ(p.GetPacket().Pass(),
+                   rtcp_builder_->BuildRtcpFromReceiver(
+                       &report_block,
+                       NULL,
+                       NULL,
+                       &rtcp_events,
+                       kDefaultDelay));
 
     testing_clock.Advance(
         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
     time_base_ms += kTimeBetweenEventsMs;
   }
-
-  EXPECT_EQ(static_cast<int>(packet_count), test_transport_.packet_count());
 }
 
-TEST_F(RtcpSenderTest, RtcpSenderReport) {
+TEST_F(RtcpBuilderTest, RtcpSenderReport) {
   RtcpSenderInfo sender_info;
   sender_info.ntp_seconds = kNtpHigh;
   sender_info.ntp_fraction = kNtpLow;
   sender_info.rtp_timestamp = kRtpTimestamp;
   sender_info.send_packet_count = kSendPacketCount;
   sender_info.send_octet_count = kSendOctetCount;
 
   // Sender report.
   TestRtcpPacketBuilder p;
   p.AddSr(kSendingSsrc, 0);
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
-  rtcp_sender_->SendRtcpFromRtpSender(sender_info);
-
-  EXPECT_EQ(1, test_transport_.packet_count());
+  ExpectPacketEQ(p.GetPacket().Pass(),
+                 rtcp_builder_->BuildRtcpFromSender(sender_info));
 }
 
 }  // namespace cast
 }  // namespace media