Refactor of QUIC's rtt storage and calculation to have a single RttStats

net/quic/congestion_control/inter_arrival_sender_test.cc

 // Copyright (c) 2013 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 "net/quic/congestion_control/inter_arrival_sender.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
+#include "net/quic/congestion_control/rtt_stats.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::pair;
 
 namespace net {
 namespace test {
 
 class InterArrivalSenderTest : public ::testing::Test {
  protected:
   InterArrivalSenderTest()
      : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
        one_s_(QuicTime::Delta::FromMilliseconds(1000)),
        nine_ms_(QuicTime::Delta::FromMilliseconds(9)),
        send_start_time_(send_clock_.Now()),
-       sender_(&send_clock_),
+       sender_(&send_clock_, &rtt_stats_),
        sequence_number_(1),
        acked_sequence_number_(1),
        feedback_sequence_number_(1) {
     send_clock_.AdvanceTime(one_ms_);
     receive_clock_.AdvanceTime(one_ms_);
+    rtt_stats_.set_initial_rtt_us(60 * base::Time::kMicrosecondsPerMillisecond);
   }
 
   virtual ~InterArrivalSenderTest() {
   }
 
   void SendAvailableCongestionWindow() {
     while (sender_.TimeUntilSend(send_clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero()) {
       QuicByteCount bytes_in_packet = kDefaultMaxPacketSize;
       sender_.OnPacketSent(send_clock_.Now(), sequence_number_, bytes_in_packet,
@@ skipping 54 matching lines @@
   QuicTime::Delta SenderDeltaSinceStart() {
     return send_clock_.ApproximateNow().Subtract(send_start_time_);
   }
 
   const QuicTime::Delta one_ms_;
   const QuicTime::Delta one_s_;
   const QuicTime::Delta nine_ms_;
   MockClock send_clock_;
   MockClock receive_clock_;
   const QuicTime send_start_time_;
+  RttStats rtt_stats_;
   InterArrivalSender sender_;
   QuicPacketSequenceNumber sequence_number_;
   QuicPacketSequenceNumber acked_sequence_number_;
   QuicPacketSequenceNumber feedback_sequence_number_;
 };
 
 TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
@@ skipping 434 matching lines @@
     acked_sequence_number_ += 2;  // Create a loss by not acking both packets.
     SendFeedbackMessageNPackets(2, nine_ms_, nine_ms_);
 
     // Make sure our bitrate is fixed at the expected_min_bitrate.
     EXPECT_EQ(expected_min_bitrate, sender_.BandwidthEstimate());
   }
 }
 
 }  // namespace test
 }  // namespace net