Landing Recent QUIC changes until May 20, 2017.

net/quic/core/congestion_control/bandwidth_sampler_test.cc

 // Copyright 2016 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/core/congestion_control/bandwidth_sampler.h"
 
+#include "net/quic/platform/api/quic_flags.h"
 #include "net/quic/platform/api/quic_test.h"
 #include "net/quic/test_tools/mock_clock.h"
 
 namespace net {
 namespace test {
 
 class BandwidthSamplerPeer {
  public:
   static size_t GetNumberOfTrackedPackets(const BandwidthSampler& sampler) {
+    if (FLAGS_quic_reloadable_flag_quic_faster_bandwidth_sampler) {
+      return sampler.connection_state_map_new_.number_of_present_entries();
+    }
     return sampler.connection_state_map_.size();
   }
 
   static QuicByteCount GetPacketSize(const BandwidthSampler& sampler,
                                      QuicPacketNumber packet_number) {
+    if (FLAGS_quic_reloadable_flag_quic_faster_bandwidth_sampler) {
+      return sampler.connection_state_map_new_.GetEntry(packet_number)->size;
+    }
     auto iterator = sampler.connection_state_map_.find(packet_number);
     return iterator->second.size;
   }
 };
 
 const QuicByteCount kRegularPacketSize = 1280;
 // Enforce divisibility for some of the tests.
 static_assert((kRegularPacketSize & 31) == 0,
               "kRegularPacketSize has to be five times divisible by 2");
 
@@ skipping 159 matching lines @@
 // the SendWithLosses test.
 TEST_F(BandwidthSamplerTest, NotCongestionControlled) {
   const QuicTime::Delta time_between_packets =
       QuicTime::Delta::FromMilliseconds(1);
   QuicBandwidth expected_bandwidth =
       QuicBandwidth::FromKBytesPerSecond(kRegularPacketSize) * 0.5;
 
   // Send 20 packets, each 1 ms apart. Every even packet is not congestion
   // controlled.
   for (QuicPacketNumber i = 1; i <= 20; i++) {
-    SendPacketInner(i, kRegularPacketSize, i % 2 == 0
-                                               ? HAS_RETRANSMITTABLE_DATA
-                                               : NO_RETRANSMITTABLE_DATA);
+    SendPacketInner(
+        i, kRegularPacketSize,
+        i % 2 == 0 ? HAS_RETRANSMITTABLE_DATA : NO_RETRANSMITTABLE_DATA);
     clock_.AdvanceTime(time_between_packets);
   }
 
   // Ensure only congestion controlled packets are tracked.
   EXPECT_EQ(10u, BandwidthSamplerPeer::GetNumberOfTrackedPackets(sampler_));
 
   // Ack packets 2 to 21, ignoring every even-numbered packet, while sending new
   // packets at the same rate as before.
   for (QuicPacketNumber i = 1; i <= 20; i++) {
     if (i % 2 == 0) {
       AckPacket(i);
     }
-    SendPacketInner(i + 20, kRegularPacketSize, i % 2 == 0
-                                                    ? HAS_RETRANSMITTABLE_DATA
-                                                    : NO_RETRANSMITTABLE_DATA);
+    SendPacketInner(
+        i + 20, kRegularPacketSize,
+        i % 2 == 0 ? HAS_RETRANSMITTABLE_DATA : NO_RETRANSMITTABLE_DATA);
     clock_.AdvanceTime(time_between_packets);
   }
 
   // Ack the packets 22 to 41 with the same congestion controlled pattern.
   QuicBandwidth last_bandwidth = QuicBandwidth::Zero();
   for (QuicPacketNumber i = 21; i <= 40; i++) {
     if (i % 2 == 0) {
       last_bandwidth = AckPacket(i);
       EXPECT_EQ(expected_bandwidth, last_bandwidth);
     }
@@ skipping 160 matching lines @@
   sampler_.RemoveObsoletePackets(4);
   EXPECT_EQ(2u, BandwidthSamplerPeer::GetNumberOfTrackedPackets(sampler_));
   sampler_.OnPacketLost(4);
   EXPECT_EQ(1u, BandwidthSamplerPeer::GetNumberOfTrackedPackets(sampler_));
   AckPacket(5);
   EXPECT_EQ(0u, BandwidthSamplerPeer::GetNumberOfTrackedPackets(sampler_));
 }
 
 }  // namespace test
 }  // namespace net