Minor code redundancy cleanup.

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"
@@ skipping 252 matching lines @@
                    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));
 
   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1, 1, 1);
   RunTasks(33);
   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
-  EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
-  EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2);
-  EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2);
-  EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2);
-  EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 2, 1, 1);
   RunTasks(33);
-  EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
-
-  EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2);
-  EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2);
-  EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2);
-  EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 }
 
 TEST_F(RtcpTest, Rtt) {
   // Media receiver.
   Rtcp rtcp_receiver(RtcpCastMessageCallback(),
                      RtcpRttCallback(),
                      RtcpLogMessageCallback(),
                      testing_clock_,
                      &receiver_to_sender_,
                      kReceiverSsrc,
@@ skipping 11 matching lines @@
                    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));
 
   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1, 1, 1);
   RunTasks(33);
   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 
   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
   RunTasks(33);
 
-  EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
   RunTasks(33);
 
   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2);
   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2);
   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2);
   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 
   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 2, 1, 1);
   RunTasks(33);
-  EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
-  EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2);
-  EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2);
-  EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2);
-  EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 
   receiver_to_sender_.set_short_delay();
   sender_to_receiver_.set_short_delay();
   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
   EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 2);
   EXPECT_NEAR(
       (kAddedShortDelay + 3 * kAddedDelay) / 2, avg_rtt.InMilliseconds(), 2);
   EXPECT_NEAR(kAddedDelay + kAddedShortDelay, min_rtt.InMilliseconds(), 2);
   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 
   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 3, 1, 1);
   RunTasks(33);
-  EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
-  EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 1);
-  EXPECT_NEAR((2 * kAddedShortDelay + 2 * kAddedDelay) / 2,
-              avg_rtt.InMilliseconds(),
-              1);
-  EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2);
-  EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 
   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
   EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2);
   EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2);
   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 
   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
   EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2);
@@ skipping 27 matching lines @@
 
   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;
   base::TimeDelta min_rtt;
   base::TimeDelta max_rtt;
   EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
-  EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
-  EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 1);
-  EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 1);
-  EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 1);
-  EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 
   receiver_to_sender_.set_short_delay();
   sender_to_receiver_.set_short_delay();
   receiver_to_sender_.set_drop_packets(true);
 
   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1, 1, 1);
   RunTasks(33);
 
-  EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
-  EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 2);
 }
 
 TEST_F(RtcpTest, NtpAndTime) {
   const int64 kSecondsbetweenYear1900and2010 = INT64_C(40176 * 24 * 60 * 60);
   const int64 kSecondsbetweenYear1900and2030 = INT64_C(47481 * 24 * 60 * 60);
 
   uint32 ntp_seconds_1 = 0;
   uint32 ntp_fraction_1 = 0;
   base::TimeTicks input_time = base::TimeTicks::Now();
   ConvertTimeTicksToNtp(input_time, &ntp_seconds_1, &ntp_fraction_1);
@@ skipping 30 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