Cast: Make receiver use cast_transport

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"
@@ skipping 29 matching lines @@
 }  // namespace
 
 
 class RtcpBuilderTest : public ::testing::Test {
  protected:
   RtcpBuilderTest()
       : rtcp_builder_(new RtcpBuilder(kSendingSsrc)) {}
 
   void ExpectPacketEQ(scoped_ptr<Packet> golden_packet,
                       PacketRef packet) {
+    int diffs = 0;
     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]);
+        EXPECT_EQ((*golden_packet)[x], packet->data[x]) <<
+            "x = " << x << " / " << golden_packet->size();
         if ((*golden_packet)[x] != packet->data[x])

[miu, 2014/12/04 04:18:54]

nit: braces around then-clause

[hubbe, 2014/12/05 23:57:20]

Done.

-          break;
+          if (++diffs > 5)
+            break;
       }
     }
   }
 
   scoped_ptr<RtcpBuilder> rtcp_builder_;
 
   DISALLOW_COPY_AND_ASSIGN(RtcpBuilderTest);
 };
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReport) {
@@ skipping 118 matching lines @@
   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;
+  ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
 
   ExpectPacketEQ(p.GetPacket().Pass(),
                  rtcp_builder_->BuildRtcpFromReceiver(
                      &report_block,
                      &rrtr,
                      &cast_message,
                      &rtcp_events,
                      kDefaultDelay));
 
   base::SimpleTestTickClock testing_clock;
@@ skipping 12 matching lines @@
   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);
+  event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
   EXPECT_EQ(2u, rtcp_events.size());
 
   ExpectPacketEQ(
       p.GetPacket().Pass(),
       rtcp_builder_->BuildRtcpFromReceiver(
           &report_block,
           &rrtr,
           &cast_message,
           &rtcp_events,
           kDefaultDelay));
 }
 
 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;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
 
-  int remaining_bytes = kMaxReceiverLogBytes;
-  remaining_bytes -= kRtcpCastLogHeaderSize;
+  int num_events = kMaxEventsPerRTCP;
 
-  remaining_bytes -= kRtcpReceiverFrameLogSize;
-  int num_events = remaining_bytes / kRtcpReceiverEventLogSize;
   EXPECT_LE(num_events, static_cast<int>(kRtcpMaxReceiverLogMessages));
-  // Only the last |num_events| events are sent due to receiver log size cap.
   p.AddReceiverFrameLog(
       kRtpTimestamp + 2345,
       num_events,
-      kTimeBaseMs + (kRtcpMaxReceiverLogMessages - num_events) * kTimeDelayMs);
+      kTimeBaseMs);
   for (int i = 0; i < num_events; i++) {
     p.AddReceiverEventLog(
-        kLostPacketId1, PACKET_RECEIVED,
+        kLostPacketId1,
+        PACKET_RECEIVED,
         static_cast<uint16>(kTimeDelayMs * i));
   }
 
 
   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);
+  ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
+  event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
   ExpectPacketEQ(p.GetPacket().Pass(),
                  rtcp_builder_->BuildRtcpFromReceiver(
                      &report_block,
                      NULL,
                      NULL,
                      &rtcp_events,
                      kDefaultDelay));
 }
 
 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 = kMaxEventsPerRTCP;
 
-  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) {
+  for (int i = 0; i < num_events; i++) {
     p.AddReceiverFrameLog(kRtpTimestamp + i, 1, kTimeBaseMs + i * kTimeDelayMs);
     p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
   }
 
   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);
+  ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
+  event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
   ExpectPacketEQ(p.GetPacket().Pass(),
                  rtcp_builder_->BuildRtcpFromReceiver(
                      &report_block,
                      NULL,
                      NULL,
                      &rtcp_events,
                      kDefaultDelay));
 }
 
@@ skipping 25 matching lines @@
     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);
+  ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
+  event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
   ExpectPacketEQ(p.GetPacket().Pass(),
                  rtcp_builder_->BuildRtcpFromReceiver(
                      &report_block,
                      NULL,
                      NULL,
                      &rtcp_events,
                      kDefaultDelay));
 }
 
 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;
+  size_t packet_count = kNumResends * kResendDelay + 10;
   for (size_t i = 0; i < packet_count; i++) {
     TestRtcpPacketBuilder p;
     p.AddRr(kSendingSsrc, 1);
     p.AddRb(kMediaSsrc);
 
     p.AddReceiverLog(kSendingSsrc);
 
-    if (i >= kSecondRedundancyOffset) {
-      p.AddReceiverFrameLog(
-          kRtpTimestamp,
-          1,
-          time_base_ms - kSecondRedundancyOffset * kTimeBetweenEventsMs);
-      p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
+    int num_events = (i + kResendDelay) / kResendDelay;
+    num_events = std::min<int>(num_events, kNumResends);
+    p.AddReceiverFrameLog(kRtpTimestamp, num_events,
+        time_base_ms - (num_events - 1) * kResendDelay *
+        kTimeBetweenEventsMs);
+    for (int i = 0; i < num_events; i++) {
+      p.AddReceiverEventLog(0, FRAME_ACK_SENT,
+        i * kResendDelay * kTimeBetweenEventsMs);
     }
-    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);
 
     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);
+    ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
+    event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
     ExpectPacketEQ(p.GetPacket().Pass(),
                    rtcp_builder_->BuildRtcpFromReceiver(
                        &report_block,
                        NULL,
                        NULL,
                        &rtcp_events,
                        kDefaultDelay));
 
     testing_clock.Advance(
@@ skipping 13 matching lines @@
   // Sender report.
   TestRtcpPacketBuilder p;
   p.AddSr(kSendingSsrc, 0);
 
   ExpectPacketEQ(p.GetPacket().Pass(),
                  rtcp_builder_->BuildRtcpFromSender(sender_info));
 }
 
 }  // namespace cast
 }  // namespace media