Cast: Remove unused RTCP messages

media/cast/net/rtcp/rtcp_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 "base/test/simple_test_tick_clock.h"
 #include "media/cast/cast_defines.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/mock_rtcp_receiver_feedback.h"
 #include "media/cast/net/rtcp/rtcp.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 {
 
 using testing::_;
 
 static const uint32 kSenderSsrc = 0x10203;
 static const uint32 kReceiverSsrc = 0x40506;
-static const std::string kCName("test@10.1.1.1");
 static const int64 kAddedDelay = 123;
 static const int64 kAddedShortDelay = 100;
 
 class RtcpTestPacketSender : public PacketSender {
  public:
   explicit RtcpTestPacketSender(base::SimpleTestTickClock* testing_clock)
       : drop_packets_(false),
         short_delay_(false),
         rtcp_receiver_(NULL),
         testing_clock_(testing_clock) {}
@@ skipping 155 matching lines @@
 
 TEST_F(RtcpTest, BasicSenderReport) {
   Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                        base::Unretained(&mock_frame_sender_)),
             base::Bind(&MockFrameSender::OnReceivedRtt,
                        base::Unretained(&mock_frame_sender_)),
             RtcpLogMessageCallback(),
             testing_clock_,
             &sender_to_receiver_,
             kSenderSsrc,
-            kReceiverSsrc,
-            kCName);
+            kReceiverSsrc);
   sender_to_receiver_.set_rtcp_receiver(&rtcp);
   rtcp.SendRtcpFromRtpSender(base::TimeTicks(), 0, 1, 1);
 }
 
 TEST_F(RtcpTest, BasicReceiverReport) {
   Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                        base::Unretained(&mock_frame_sender_)),
             base::Bind(&MockFrameSender::OnReceivedRtt,
                        base::Unretained(&mock_frame_sender_)),
             RtcpLogMessageCallback(),
             testing_clock_,
             &receiver_to_sender_,
             kSenderSsrc,
-            kReceiverSsrc,
-            kCName);
+            kReceiverSsrc);
   receiver_to_sender_.set_rtcp_receiver(&rtcp);
   rtcp.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 }
 
 TEST_F(RtcpTest, BasicCast) {
   EXPECT_CALL(mock_frame_sender_, OnReceivedCastFeedback(_)).Times(1);
 
   // Media sender.
   Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                        base::Unretained(&mock_frame_sender_)),
             base::Bind(&MockFrameSender::OnReceivedRtt,
                        base::Unretained(&mock_frame_sender_)),
             RtcpLogMessageCallback(),
             testing_clock_,
             &receiver_to_sender_,
             kSenderSsrc,
-            kSenderSsrc,
-            kCName);
+            kSenderSsrc);
   receiver_to_sender_.set_rtcp_receiver(&rtcp);
   RtcpCastMessage cast_message(kSenderSsrc);
   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.SendRtcpFromRtpReceiver(&cast_message, base::TimeDelta(), NULL, NULL);
 }
 
 TEST_F(RtcpTest, RttReducedSizeRtcp) {
   // Media receiver.
   Rtcp rtcp_receiver(RtcpCastMessageCallback(),
                      RtcpRttCallback(),
                      RtcpLogMessageCallback(),
                      testing_clock_,
                      &receiver_to_sender_,
                      kReceiverSsrc,
-                     kSenderSsrc,
-                     kCName);
+                     kSenderSsrc);
 
   // Media sender.
   Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                               base::Unretained(&mock_frame_sender_)),
                    base::Bind(&MockFrameSender::OnReceivedRtt,
                               base::Unretained(&mock_frame_sender_)),
                    RtcpLogMessageCallback(),
                    testing_clock_,
                    &sender_to_receiver_,
                    kSenderSsrc,
-                   kReceiverSsrc,
-                   kCName);
+                   kReceiverSsrc);
 
   sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver);
   receiver_to_sender_.set_rtcp_receiver(&rtcp_sender);
 
   base::TimeDelta rtt;
   base::TimeDelta avg_rtt;
   base::TimeDelta min_rtt;
   base::TimeDelta max_rtt;
   EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
   EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
@@ skipping 18 matching lines @@
 }
 
 TEST_F(RtcpTest, Rtt) {
   // Media receiver.
   Rtcp rtcp_receiver(RtcpCastMessageCallback(),
                      RtcpRttCallback(),
                      RtcpLogMessageCallback(),
                      testing_clock_,
                      &receiver_to_sender_,
                      kReceiverSsrc,
-                     kSenderSsrc,
-                     kCName);
+                     kSenderSsrc);
 
   // Media sender.
   Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                               base::Unretained(&mock_frame_sender_)),
                    base::Bind(&MockFrameSender::OnReceivedRtt,
                               base::Unretained(&mock_frame_sender_)),
                    RtcpLogMessageCallback(),
                    testing_clock_,
                    &sender_to_receiver_,
                    kSenderSsrc,
-                   kReceiverSsrc,
-                   kCName);
+                   kReceiverSsrc);
 
   receiver_to_sender_.set_rtcp_receiver(&rtcp_sender);
   sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver);
 
   base::TimeDelta rtt;
   base::TimeDelta avg_rtt;
   base::TimeDelta min_rtt;
   base::TimeDelta max_rtt;
   EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
   EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
@@ skipping 55 matching lines @@
 }
 
 TEST_F(RtcpTest, RttWithPacketLoss) {
   // Media receiver.
   Rtcp rtcp_receiver(RtcpCastMessageCallback(),
                      RtcpRttCallback(),
                      RtcpLogMessageCallback(),
                      testing_clock_,
                      &receiver_to_sender_,
                      kReceiverSsrc,
-                     kSenderSsrc,
-                     kCName);
+                     kSenderSsrc);
 
   // Media sender.
   Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                               base::Unretained(&mock_frame_sender_)),
                    base::Bind(&MockFrameSender::OnReceivedRtt,
                               base::Unretained(&mock_frame_sender_)),
                    RtcpLogMessageCallback(),
                    testing_clock_,
                    &sender_to_receiver_,
                    kSenderSsrc,
-                   kReceiverSsrc,
-                   kCName);
+                   kReceiverSsrc);
 
   receiver_to_sender_.set_rtcp_receiver(&rtcp_sender);
   sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver);
 
   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 0, 1, 1);
   RunTasks(33);
 
   base::TimeDelta rtt;
   base::TimeDelta avg_rtt;
@@ skipping 59 matching lines @@
   base::TimeTicks out_3 = ConvertNtpToTimeTicks(ntp_seconds_3, ntp_fraction_3);
   EXPECT_EQ(input_time, out_3);  // Verify inverse.
 
   // Verify delta.
   EXPECT_EQ((out_3 - out_2), time_delta);
   EXPECT_NEAR((ntp_fraction_3 - ntp_fraction_2), 0xffffffff / 2, 1);
 }
 
 }  // namespace cast
 }  // namespace media