Remove GetRttStats from QuicSentPacketManagerPeer.

net/quic/quic_sent_packet_manager_test.cc

 // Copyright 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/quic_sent_packet_manager.h"
 
 #include <memory>
 
 #include "base/stl_util.h"
 #include "net/quic/quic_flags.h"
@@ skipping 633 matching lines @@
 TEST_P(QuicSentPacketManagerTest, Rtt) {
   QuicPacketNumber packet_number = 1;
   QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(15);
   SendDataPacket(packet_number);
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
 
   ExpectAck(packet_number);
   QuicAckFrame ack_frame = InitAckFrame(packet_number);
   ack_frame.ack_delay_time = QuicTime::Delta::FromMilliseconds(5);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
-  EXPECT_EQ(expected_rtt,
-            QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
+  EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
 }
 
 TEST_P(QuicSentPacketManagerTest, RttWithInvalidDelta) {
   // Expect that the RTT is equal to the local time elapsed, since the
   // ack_delay_time is larger than the local time elapsed
   // and is hence invalid.
   QuicPacketNumber packet_number = 1;
   QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
   SendDataPacket(packet_number);
   clock_.AdvanceTime(expected_rtt);
 
   ExpectAck(packet_number);
   QuicAckFrame ack_frame = InitAckFrame(packet_number);
   ack_frame.ack_delay_time = QuicTime::Delta::FromMilliseconds(11);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
-  EXPECT_EQ(expected_rtt,
-            QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
+  EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
 }
 
 TEST_P(QuicSentPacketManagerTest, RttWithInfiniteDelta) {
   // Expect that the RTT is equal to the local time elapsed, since the
   // ack_delay_time is infinite, and is hence invalid.
   QuicPacketNumber packet_number = 1;
   QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
   SendDataPacket(packet_number);
   clock_.AdvanceTime(expected_rtt);
 
   ExpectAck(packet_number);
   QuicAckFrame ack_frame = InitAckFrame(packet_number);
   ack_frame.ack_delay_time = QuicTime::Delta::Infinite();
   manager_.OnIncomingAck(ack_frame, clock_.Now());
-  EXPECT_EQ(expected_rtt,
-            QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
+  EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
 }
 
 TEST_P(QuicSentPacketManagerTest, RttZeroDelta) {
   // Expect that the RTT is the time between send and receive since the
   // ack_delay_time is zero.
   QuicPacketNumber packet_number = 1;
   QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
   SendDataPacket(packet_number);
   clock_.AdvanceTime(expected_rtt);
 
   ExpectAck(packet_number);
   QuicAckFrame ack_frame = InitAckFrame(packet_number);
   ack_frame.ack_delay_time = QuicTime::Delta::Zero();
   manager_.OnIncomingAck(ack_frame, clock_.Now());
-  EXPECT_EQ(expected_rtt,
-            QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
+  EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
 }
 
 TEST_P(QuicSentPacketManagerTest, TailLossProbeTimeout) {
   QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
 
   // Send 1 packet.
   QuicPacketNumber packet_number = 1;
   SendDataPacket(packet_number);
 
   // The first tail loss probe retransmits 1 packet.
@@ skipping 467 matching lines @@
 }
 
 TEST_P(QuicSentPacketManagerTest, GetTransmissionTime) {
   EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
 }
 
 TEST_P(QuicSentPacketManagerTest, GetTransmissionTimeCryptoHandshake) {
   SendCryptoPacket(1);
 
   // Check the min.
-  RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(&manager_);
+  RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
   rtt_stats->set_initial_rtt_us(1 * kNumMicrosPerMilli);
   EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)),
             manager_.GetRetransmissionTime());
 
   // Test with a standard smoothed RTT.
   rtt_stats->set_initial_rtt_us(100 * kNumMicrosPerMilli);
 
   QuicTime::Delta srtt =
       QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us());
   QuicTime expected_time = clock_.Now().Add(srtt.Multiply(1.5));
   EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
 
   // Retransmit the packet by invoking the retransmission timeout.
   clock_.AdvanceTime(srtt.Multiply(1.5));
   manager_.OnRetransmissionTimeout();
   RetransmitNextPacket(2);
 
   // The retransmission time should now be twice as far in the future.
   expected_time = clock_.Now().Add(srtt.Multiply(2).Multiply(1.5));
   EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
 }
 
 TEST_P(QuicSentPacketManagerTest, GetTransmissionTimeTailLossProbe) {
   QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
   SendDataPacket(1);
   SendDataPacket(2);
 
   // Check the min.
-  RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(&manager_);
+  RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
   rtt_stats->set_initial_rtt_us(1 * kNumMicrosPerMilli);
   EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)),
             manager_.GetRetransmissionTime());
 
   // Test with a standard smoothed RTT.
   rtt_stats->set_initial_rtt_us(100 * kNumMicrosPerMilli);
   QuicTime::Delta srtt =
       QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us());
   QuicTime::Delta expected_tlp_delay = srtt.Multiply(2);
   QuicTime expected_time = clock_.Now().Add(expected_tlp_delay);
@@ skipping 12 matching lines @@
       .WillOnce(Return(QuicTime::Delta::Infinite()));
   EXPECT_EQ(QuicTime::Delta::Infinite(),
             manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   expected_time = clock_.Now().Add(expected_tlp_delay);
   EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
 }
 
 TEST_P(QuicSentPacketManagerTest, GetTransmissionTimeSpuriousRTO) {
-  QuicSentPacketManagerPeer::GetRttStats(&manager_)
+  const_cast<RttStats*>(manager_.GetRttStats())
       ->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
                   QuicTime::Delta::Zero(), QuicTime::Zero());
-
   SendDataPacket(1);
   SendDataPacket(2);
   SendDataPacket(3);
   SendDataPacket(4);
 
   QuicTime::Delta expected_rto_delay = QuicTime::Delta::FromMilliseconds(500);
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillRepeatedly(Return(expected_rto_delay));
   QuicTime expected_time = clock_.Now().Add(expected_rto_delay);
   EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
@@ skipping 435 matching lines @@
   CachedNetworkParameters cached_network_params;
   cached_network_params.set_min_rtt_ms(kRttMs);
 
   EXPECT_CALL(*send_algorithm_, ResumeConnectionState(_, false));
   manager_.ResumeConnectionState(cached_network_params, false);
   EXPECT_EQ(kRttMs * kNumMicrosPerMilli,
             static_cast<uint64_t>(manager_.GetRttStats()->initial_rtt_us()));
 }
 
 TEST_P(QuicSentPacketManagerTest, ConnectionMigrationUnspecifiedChange) {
-  RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(&manager_);
+  RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
   int64_t default_init_rtt = rtt_stats->initial_rtt_us();
   rtt_stats->set_initial_rtt_us(default_init_rtt * 2);
   EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us());
 
   QuicSentPacketManagerPeer::SetConsecutiveRtoCount(&manager_, 1);
   EXPECT_EQ(1u, manager_.consecutive_rto_count());
   QuicSentPacketManagerPeer::SetConsecutiveTlpCount(&manager_, 2);
   EXPECT_EQ(2u, manager_.consecutive_tlp_count());
 
   EXPECT_CALL(*send_algorithm_, OnConnectionMigration());
   manager_.OnConnectionMigration(UNSPECIFIED_CHANGE);
 
   EXPECT_EQ(default_init_rtt, rtt_stats->initial_rtt_us());
   EXPECT_EQ(0u, manager_.consecutive_rto_count());
   EXPECT_EQ(0u, manager_.consecutive_tlp_count());
 }
 
 TEST_P(QuicSentPacketManagerTest, ConnectionMigrationIPSubnetChange) {
-  RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(&manager_);
+  RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
   int64_t default_init_rtt = rtt_stats->initial_rtt_us();
   rtt_stats->set_initial_rtt_us(default_init_rtt * 2);
   EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us());
 
   QuicSentPacketManagerPeer::SetConsecutiveRtoCount(&manager_, 1);
   EXPECT_EQ(1u, manager_.consecutive_rto_count());
   QuicSentPacketManagerPeer::SetConsecutiveTlpCount(&manager_, 2);
   EXPECT_EQ(2u, manager_.consecutive_tlp_count());
 
   manager_.OnConnectionMigration(IPV4_SUBNET_CHANGE);
 
   EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us());
   EXPECT_EQ(1u, manager_.consecutive_rto_count());
   EXPECT_EQ(2u, manager_.consecutive_tlp_count());
 }
 
 TEST_P(QuicSentPacketManagerTest, ConnectionMigrationPortChange) {
-  RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(&manager_);
+  RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
   int64_t default_init_rtt = rtt_stats->initial_rtt_us();
   rtt_stats->set_initial_rtt_us(default_init_rtt * 2);
   EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us());
 
   QuicSentPacketManagerPeer::SetConsecutiveRtoCount(&manager_, 1);
   EXPECT_EQ(1u, manager_.consecutive_rto_count());
   QuicSentPacketManagerPeer::SetConsecutiveTlpCount(&manager_, 2);
   EXPECT_EQ(2u, manager_.consecutive_tlp_count());
 
   manager_.OnConnectionMigration(PORT_CHANGE);
 
   EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us());
   EXPECT_EQ(1u, manager_.consecutive_rto_count());
   EXPECT_EQ(2u, manager_.consecutive_tlp_count());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net