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

media/cast/net/rtcp/rtcp_builder_unittest.cc

Index: media/cast/net/rtcp/rtcp_builder_unittest.cc
diff --git a/media/cast/net/rtcp/rtcp_sender_unittest.cc b/media/cast/net/rtcp/rtcp_builder_unittest.cc
similarity index 70%
rename from media/cast/net/rtcp/rtcp_sender_unittest.cc
rename to media/cast/net/rtcp/rtcp_builder_unittest.cc
index 6dbea4d94eb286856c7b6f7eef0f45635395c5fd..e68444aef32d426eb2633620b23aa84557b5120f 100644
--- a/media/cast/net/rtcp/rtcp_sender_unittest.cc
+++ b/media/cast/net/rtcp/rtcp_builder_unittest.cc
@@ -9,10 +9,9 @@
 #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 {
@@ -40,93 +39,50 @@ RtcpReportBlock GetReportBlock() {
 
 }  // 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;
-  }
-
-  virtual bool SendPackets(
-      const SendPacketVector& packets) OVERRIDE {
-    return false;
-  }
-  virtual bool ResendPackets(
-      const SendPacketVector& packets,
-      const DedupInfo& dedup_info) OVERRIDE {
-    return false;
-  }
-
-  virtual void CancelSendingPacket(
-      const PacketKey& packet_key) OVERRIDE {
-  }
 
-  void SetExpectedRtcpPacket(scoped_ptr<Packet> packet) {
-    expected_packet_.swap(*packet);
+class RtcpBuilderTest : public ::testing::Test {
+ protected:
+  RtcpBuilderTest()
+      : 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;
+      }
+    }
   }
 
-  int packet_count() const { return packet_count_; }
-
- private:
-  Packet expected_packet_;
-  int packet_count_;
+  scoped_ptr<RtcpBuilder> rtcp_builder_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestRtcpTransport);
-};
-
-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);
+  DISALLOW_COPY_AND_ASSIGN(RtcpBuilderTest);
 };
 
-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();
 
@@ -134,23 +90,21 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) {
   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();
 
@@ -165,24 +119,22 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) {
   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();
 
@@ -201,17 +153,16 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtraAndCastMessage) {
   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;
 
@@ -221,7 +172,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
   p.AddXrHeader(kSendingSsrc);
   p.AddXrRrtrBlock();
   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
   RtcpReportBlock report_block = GetReportBlock();
 
@@ -243,12 +193,13 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
   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));
@@ -258,8 +209,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
   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;
@@ -278,17 +227,17 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
   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;
 
@@ -320,7 +269,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) {
         static_cast<uint16>(kTimeDelayMs * i));
   }
 
-  test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   FrameEvent frame_event;
@@ -344,17 +292,16 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) {
   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;
 
@@ -382,7 +329,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) {
     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);
 
@@ -399,17 +345,16 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) {
   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;
@@ -431,7 +376,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) {
   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) {
@@ -448,17 +392,16 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) {
   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;
 
@@ -493,8 +436,6 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) {
     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;
@@ -505,22 +446,21 @@ TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) {
     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;
@@ -531,11 +471,9 @@ TEST_F(RtcpSenderTest, RtcpSenderReport) {
   // 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