Minor code redundancy cleanup.

media/cast/net/rtcp/rtcp_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 "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 87 matching lines @@
   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) {
-  // Empty receiver report.
-  TestRtcpPacketBuilder p1;
-  p1.AddRr(kSendingSsrc, 0);
-  test_transport_.SetExpectedRtcpPacket(p1.GetPacket());
-
-  rtcp_sender_->SendRtcpFromRtpReceiver(
-      kRtcpRr, NULL, NULL, NULL, NULL, kDefaultDelay);
-
-  EXPECT_EQ(1, test_transport_.packet_count());
-
   // 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(
-      kRtcpRr, &report_block, NULL, NULL, NULL, kDefaultDelay);
+      &report_block, NULL, NULL, NULL, kDefaultDelay);
 
-  EXPECT_EQ(2, test_transport_.packet_count());
+  EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, 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(
-      kRtcpRr | kRtcpRrtr,
       &report_block,
       &rrtr,
       NULL,
       NULL,
       kDefaultDelay);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) {
@@ skipping 11 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;
 
   rtcp_sender_->SendRtcpFromRtpReceiver(
-      kRtcpRr | kRtcpCast,
       &report_block,
       NULL,
       &cast_message,
       NULL,
       kDefaultDelay);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtraAndCastMessage) {
@@ skipping 16 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;
 
   rtcp_sender_->SendRtcpFromRtpReceiver(
-      kRtcpRr | kRtcpRrtr | kRtcpCast,
       &report_block,
       &rrtr,
       &cast_message,
       NULL,
       kDefaultDelay);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
@@ skipping 22 matching lines @@
   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(
-      kRtcpRr | kRtcpRrtr | kRtcpCast |
-          kRtcpReceiverLog,
       &report_block,
       &rrtr,
       &cast_message,
       &rtcp_events,
       kDefaultDelay);
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
@@ skipping 15 matching lines @@
   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(
-      kRtcpRr | kRtcpRrtr | kRtcpCast |
-          kRtcpReceiverLog,
       &report_block,
       &rrtr,
       &cast_message,
       &rtcp_events,
       kDefaultDelay);
 
   EXPECT_EQ(2, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) {
@@ skipping 46 matching lines @@
     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(
-      kRtcpRr | kRtcpReceiverLog,
       &report_block,
       NULL,
       NULL,
       &rtcp_events,
       kDefaultDelay);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) {
@@ skipping 35 matching lines @@
     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(
-      kRtcpRr | kRtcpReceiverLog,
       &report_block,
       NULL,
       NULL,
       &rtcp_events,
       kDefaultDelay);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) {
@@ skipping 29 matching lines @@
     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(
-      kRtcpRr | kRtcpReceiverLog,
       &report_block,
       NULL,
       NULL,
       &rtcp_events,
       kDefaultDelay);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) {
@@ skipping 37 matching lines @@
     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(
-        kRtcpRr | kRtcpReceiverLog,
         &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) {
   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;
 
-  RtcpDlrrReportBlock dlrr_rb;
-  dlrr_rb.last_rr = kLastRr;
-  dlrr_rb.delay_since_last_rr = kDelayLastRr;
-
   // Sender report.
   TestRtcpPacketBuilder p;
   p.AddSr(kSendingSsrc, 0);
   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
-  rtcp_sender_->SendRtcpFromRtpSender(kRtcpSr,
-                                      sender_info,
-                                      dlrr_rb);
+  rtcp_sender_->SendRtcpFromRtpSender(&sender_info, NULL);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpSenderReportWithDlrr) {
   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 + dlrr.
   TestRtcpPacketBuilder p1;
   p1.AddSr(kSendingSsrc, 0);
   p1.AddXrHeader(kSendingSsrc);
   p1.AddXrDlrrBlock(kSendingSsrc);
   test_transport_.SetExpectedRtcpPacket(p1.GetPacket().Pass());
 
   RtcpDlrrReportBlock dlrr_rb;
   dlrr_rb.last_rr = kLastRr;
   dlrr_rb.delay_since_last_rr = kDelayLastRr;
 
-  rtcp_sender_->SendRtcpFromRtpSender(
-      kRtcpSr | kRtcpDlrr,
-      sender_info,
-      dlrr_rb);
+  rtcp_sender_->SendRtcpFromRtpSender(&sender_info, &dlrr_rb);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 }  // namespace cast
 }  // namespace media