Cast: Refactor RTCP handling

media/cast/sender/video_sender_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 <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/logging/simple_event_subscriber.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/cast_transport_sender_impl.h"
 #include "media/cast/net/pacing/paced_sender.h"
+#include "media/cast/net/rtcp/rtcp_receiver.h"
 #include "media/cast/sender/video_sender.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "media/cast/test/fake_video_encode_accelerator.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 namespace cast {
@@ skipping 31 matching lines @@
         paused_(false) {}
 
   // A singular packet implies a RTCP packet.
   virtual bool SendPacket(PacketRef packet,
                           const base::Closure& cb) OVERRIDE {
     if (paused_) {
       stored_packet_ = packet;
       callback_ = cb;
       return false;
     }
-    if (Rtcp::IsRtcpPacket(&packet->data[0], packet->data.size())) {
+    if (RtcpReceiver::IsRtcpPacket(&packet->data[0], packet->data.size())) {
       ++number_of_rtcp_packets_;
     } else {
       // Check that at least one RTCP packet was sent before the first RTP
       // packet.  This confirms that the receiver will have the necessary lip
       // sync info before it has to calculate the playout time of the first
       // frame.
       if (number_of_rtp_packets_ == 0)
         EXPECT_LE(1, number_of_rtcp_packets_);
       ++number_of_rtp_packets_;
     }
@@ skipping 185 matching lines @@
 
   // Make sure that we send at least one RTCP packet.
   base::TimeDelta max_rtcp_timeout =
       base::TimeDelta::FromMilliseconds(1 + kDefaultRtcpIntervalMs * 3 / 2);
 
   RunTasks(max_rtcp_timeout.InMilliseconds());
   EXPECT_LE(1, transport_.number_of_rtp_packets());
   EXPECT_LE(1, transport_.number_of_rtcp_packets());
   // Build Cast msg and expect RTCP packet.
   RtcpCastMessage cast_feedback(1);
-  cast_feedback.media_ssrc_ = 2;
-  cast_feedback.ack_frame_id_ = 0;
+  cast_feedback.media_ssrc = 2;
+  cast_feedback.ack_frame_id = 0;
   video_sender_->OnReceivedCastFeedback(cast_feedback);
   RunTasks(max_rtcp_timeout.InMilliseconds());
   EXPECT_LE(1, transport_.number_of_rtcp_packets());
 }
 
 TEST_F(VideoSenderTest, ResendTimer) {
   InitEncoder(false);
 
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
   const base::TimeTicks capture_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, capture_time);
 
   // ACK the key frame.
   RtcpCastMessage cast_feedback(1);
-  cast_feedback.media_ssrc_ = 2;
-  cast_feedback.ack_frame_id_ = 0;
+  cast_feedback.media_ssrc = 2;
+  cast_feedback.ack_frame_id = 0;
   video_sender_->OnReceivedCastFeedback(cast_feedback);
 
   video_frame = GetNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, capture_time);
 
   base::TimeDelta max_resend_timeout =
       base::TimeDelta::FromMilliseconds(1 + kDefaultRtpMaxDelayMs);
 
   // Make sure that we do a re-send.
   RunTasks(max_resend_timeout.InMilliseconds());
@@ skipping 13 matching lines @@
     scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
     const base::TimeTicks capture_time = testing_clock_->NowTicks();
     video_sender_->InsertRawVideoFrame(video_frame, capture_time);
     RunTasks(33);
   }
 
   task_runner_->RunTasks();
 
   RtcpCastMessage cast_feedback(1);
-  cast_feedback.ack_frame_id_ = num_frames - 1;
+  cast_feedback.ack_frame_id = num_frames - 1;
 
   video_sender_->OnReceivedCastFeedback(cast_feedback);
 
   std::vector<FrameEvent> frame_events;
   event_subscriber.GetFrameEventsAndReset(&frame_events);
 
   ASSERT_TRUE(!frame_events.empty());
   EXPECT_EQ(FRAME_ACK_RECEIVED, frame_events.rbegin()->type);
   EXPECT_EQ(VIDEO_EVENT, frame_events.rbegin()->media_type);
   EXPECT_EQ(num_frames - 1u, frame_events.rbegin()->frame_id);
@@ skipping 25 matching lines @@
     RunTasks(33);
   }
 
   // We expect a frame to be retransmitted because of duplicated ACKs.
   // Only one packet of the frame is re-transmitted.
   EXPECT_EQ(number_of_packets_sent + 1,
             transport_.number_of_rtp_packets());
 
   // Start acking and make sure we're back to steady-state.
   RtcpCastMessage cast_feedback(1);
-  cast_feedback.media_ssrc_ = 2;
-  cast_feedback.ack_frame_id_ = 0;
+  cast_feedback.media_ssrc = 2;
+  cast_feedback.ack_frame_id = 0;
   video_sender_->OnReceivedCastFeedback(cast_feedback);
   EXPECT_LE(
       4,
       transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets());
 
   // Empty the pipeline.
   RunTasks(100);
   // Should have sent at least 7 packets.
   EXPECT_LE(
       7,
       transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets());
 }
 
 TEST_F(VideoSenderTest, DuplicateAckRetransmit) {
   InitEncoder(false);
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
   RtcpCastMessage cast_feedback(1);
-  cast_feedback.media_ssrc_ = 2;
-  cast_feedback.ack_frame_id_ = 0;
+  cast_feedback.media_ssrc = 2;
+  cast_feedback.ack_frame_id = 0;
 
   // Send 3 more frames but don't ACK.
   for (int i = 0; i < 3; ++i) {
     scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
     video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
     RunTasks(33);
   }
   const int number_of_packets_sent = transport_.number_of_rtp_packets();
 
   // Send duplicated ACKs and mix some invalid NACKs.
   for (int i = 0; i < 10; ++i) {
     RtcpCastMessage ack_feedback(1);
-    ack_feedback.media_ssrc_ = 2;
-    ack_feedback.ack_frame_id_ = 0;
+    ack_feedback.media_ssrc = 2;
+    ack_feedback.ack_frame_id = 0;
     RtcpCastMessage nack_feedback(1);
-    nack_feedback.media_ssrc_ = 2;
-    nack_feedback.missing_frames_and_packets_[255] = PacketIdSet();
+    nack_feedback.media_ssrc = 2;
+    nack_feedback.missing_frames_and_packets[255] = PacketIdSet();
     video_sender_->OnReceivedCastFeedback(ack_feedback);
     video_sender_->OnReceivedCastFeedback(nack_feedback);
   }
   EXPECT_EQ(number_of_packets_sent, transport_.number_of_rtp_packets());
 
   // Re-transmit one packet because of duplicated ACKs.
   for (int i = 0; i < 3; ++i) {
     RtcpCastMessage ack_feedback(1);
-    ack_feedback.media_ssrc_ = 2;
-    ack_feedback.ack_frame_id_ = 0;
+    ack_feedback.media_ssrc = 2;
+    ack_feedback.ack_frame_id = 0;
     video_sender_->OnReceivedCastFeedback(ack_feedback);
   }
   EXPECT_EQ(number_of_packets_sent + 1, transport_.number_of_rtp_packets());
 }
 
 TEST_F(VideoSenderTest, DuplicateAckRetransmitDoesNotCancelRetransmits) {
   InitEncoder(false);
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
   RtcpCastMessage cast_feedback(1);
-  cast_feedback.media_ssrc_ = 2;
-  cast_feedback.ack_frame_id_ = 0;
+  cast_feedback.media_ssrc = 2;
+  cast_feedback.ack_frame_id = 0;
 
   // Send 2 more frames but don't ACK.
   for (int i = 0; i < 2; ++i) {
     scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
     video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
     RunTasks(33);
   }
   // Pause the transport
   transport_.SetPause(true);
 
   // Insert one more video frame.
   video_frame = GetLargeNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
 
   const int number_of_packets_sent = transport_.number_of_rtp_packets();
 
   // Send duplicated ACKs and mix some invalid NACKs.
   for (int i = 0; i < 10; ++i) {
     RtcpCastMessage ack_feedback(1);
-    ack_feedback.media_ssrc_ = 2;
-    ack_feedback.ack_frame_id_ = 0;
+    ack_feedback.media_ssrc = 2;
+    ack_feedback.ack_frame_id = 0;
     RtcpCastMessage nack_feedback(1);
-    nack_feedback.media_ssrc_ = 2;
-    nack_feedback.missing_frames_and_packets_[255] = PacketIdSet();
+    nack_feedback.media_ssrc = 2;
+    nack_feedback.missing_frames_and_packets[255] = PacketIdSet();
     video_sender_->OnReceivedCastFeedback(ack_feedback);
     video_sender_->OnReceivedCastFeedback(nack_feedback);
   }
   EXPECT_EQ(number_of_packets_sent, transport_.number_of_rtp_packets());
 
   // Re-transmit one packet because of duplicated ACKs.
   for (int i = 0; i < 3; ++i) {
     RtcpCastMessage ack_feedback(1);
-    ack_feedback.media_ssrc_ = 2;
-    ack_feedback.ack_frame_id_ = 0;
+    ack_feedback.media_ssrc = 2;
+    ack_feedback.ack_frame_id = 0;
     video_sender_->OnReceivedCastFeedback(ack_feedback);
   }
 
   transport_.SetPause(false);
   RunTasks(100);
   EXPECT_LT(number_of_packets_sent + 1, transport_.number_of_rtp_packets());
 }
 
 TEST_F(VideoSenderTest, AcksCancelRetransmits) {
   InitEncoder(false);
   transport_.SetPause(true);
   scoped_refptr<media::VideoFrame> video_frame = GetLargeNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
 
   // Frame should be in buffer, waiting. Now let's ack it.
   RtcpCastMessage cast_feedback(1);
-  cast_feedback.media_ssrc_ = 2;
-  cast_feedback.ack_frame_id_ = 0;
+  cast_feedback.media_ssrc = 2;
+  cast_feedback.ack_frame_id = 0;
   video_sender_->OnReceivedCastFeedback(cast_feedback);
 
   transport_.SetPause(false);
   RunTasks(33);
   EXPECT_EQ(0, transport_.number_of_rtp_packets());
 }
 
 TEST_F(VideoSenderTest, NAcksCancelRetransmits) {
   InitEncoder(false);
   transport_.SetPause(true);
   // Send two video frames.
   scoped_refptr<media::VideoFrame> video_frame = GetLargeNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
   video_frame = GetLargeNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
 
   // Frames should be in buffer, waiting. Now let's ack the first one and nack
   // one packet in the second one.
   RtcpCastMessage cast_feedback(1);
-  cast_feedback.media_ssrc_ = 2;
-  cast_feedback.ack_frame_id_ = 0;
+  cast_feedback.media_ssrc = 2;
+  cast_feedback.ack_frame_id = 0;
   PacketIdSet missing_packets;
   missing_packets.insert(0);
-  cast_feedback.missing_frames_and_packets_[1] = missing_packets;
+  cast_feedback.missing_frames_and_packets[1] = missing_packets;
   video_sender_->OnReceivedCastFeedback(cast_feedback);
 
   transport_.SetPause(false);
   RunTasks(33);
   // Only one packet should be retransmitted.
   EXPECT_EQ(1, transport_.number_of_rtp_packets());
 }
 
 }  // namespace cast
 }  // namespace media