Landing Recent QUIC changes until May 20, 2017.

net/quic/core/quic_flow_controller_test.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 "net/quic/core/quic_flow_controller.h"
 
 #include <memory>
 
 #include "net/quic/platform/api/quic_str_cat.h"
 #include "net/quic/platform/api/quic_test.h"
@@ skipping 20 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(MockFlowController);
 };
 
 class QuicFlowControllerTest : public QuicTest {
  public:
   QuicFlowControllerTest()
       : stream_id_(1234),
         send_window_(kInitialSessionFlowControlWindowForTest),
         receive_window_(kInitialSessionFlowControlWindowForTest),
-        connection_(&helper_, &alarm_factory_, Perspective::IS_CLIENT) {
-    FLAGS_quic_reloadable_flag_quic_flow_control_faster_autotune = true;
-  }
+        connection_(&helper_, &alarm_factory_, Perspective::IS_CLIENT) {}
 
   void Initialize() {
     flow_controller_.reset(new QuicFlowController(
         &connection_, stream_id_, Perspective::IS_CLIENT, send_window_,
         receive_window_, false, &session_flow_controller_));
   }
 
  protected:
   QuicStreamId stream_id_;
   QuicByteCount send_window_;
@@ skipping 106 matching lines @@
   flow_controller_->AddBytesSent(send_window_);
   EXPECT_TRUE(flow_controller_->IsBlocked());
   EXPECT_EQ(0u, flow_controller_->SendWindowSize());
 
   // BLOCKED frame should get sent as send offset has changed.
   flow_controller_->MaybeSendBlocked();
 }
 
 TEST_F(QuicFlowControllerTest, ReceivingBytesFastIncreasesFlowWindow) {
   // This test will generate two WINDOW_UPDATE frames.
-  if (FLAGS_quic_reloadable_flag_quic_flow_control_faster_autotune) {
-    EXPECT_CALL(connection_, SendWindowUpdate(stream_id_, ::testing::_))
-        .Times(1);
-  } else {
-    EXPECT_CALL(connection_, SendWindowUpdate(stream_id_, ::testing::_))
-        .Times(2);
-  }
+  EXPECT_CALL(connection_, SendWindowUpdate(stream_id_, ::testing::_)).Times(1);
 
   Initialize();
   flow_controller_->set_auto_tune_receive_window(true);
 
   // Make sure clock is inititialized.
   connection_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
 
   QuicSentPacketManager* manager =
       QuicConnectionPeer::GetSentPacketManager(&connection_);
 
   RttStats* rtt_stats = const_cast<RttStats*>(manager->GetRttStats());
   rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(kRtt),
                        QuicTime::Delta::Zero(), QuicTime::Zero());
 
   EXPECT_FALSE(flow_controller_->IsBlocked());
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   EXPECT_EQ(kInitialSessionFlowControlWindowForTest,
             QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
 
   QuicByteCount threshold =
       QuicFlowControllerPeer::WindowUpdateThreshold(flow_controller_.get());
 
   QuicStreamOffset receive_offset = threshold + 1;
   // Receive some bytes, updating highest received offset, but not enough to
   // fill flow control receive window.
   EXPECT_TRUE(flow_controller_->UpdateHighestReceivedOffset(receive_offset));
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   EXPECT_EQ(kInitialSessionFlowControlWindowForTest - receive_offset,
             QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
-  if (FLAGS_quic_reloadable_flag_quic_flow_control_faster_autotune) {
-    EXPECT_CALL(
-        session_flow_controller_,
-        EnsureWindowAtLeast(kInitialSessionFlowControlWindowForTest * 2 * 1.5));
-  }
+  EXPECT_CALL(
+      session_flow_controller_,
+      EnsureWindowAtLeast(kInitialSessionFlowControlWindowForTest * 2 * 1.5));
 
   // Consume enough bytes to send a WINDOW_UPDATE frame.
   flow_controller_->AddBytesConsumed(threshold + 1);
   // Result is that once again we have a fully open receive window.
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
-  if (FLAGS_quic_reloadable_flag_quic_flow_control_faster_autotune) {
-    EXPECT_EQ(
-        2 * kInitialSessionFlowControlWindowForTest,
-        QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
-  } else {
-    EXPECT_EQ(
-        kInitialSessionFlowControlWindowForTest,
-        QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
-
-    // Move time forward, but by less than two RTTs.  Then receive and consume
-    // some more, forcing a second WINDOW_UPDATE with an increased max window
-    // size.
-    EXPECT_CALL(
-        session_flow_controller_,
-        EnsureWindowAtLeast(kInitialSessionFlowControlWindowForTest * 2 * 1.5));
-  }
+  EXPECT_EQ(2 * kInitialSessionFlowControlWindowForTest,
+            QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
 
   connection_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2 * kRtt - 1));
   receive_offset += threshold + 1;
   EXPECT_TRUE(flow_controller_->UpdateHighestReceivedOffset(receive_offset));
   flow_controller_->AddBytesConsumed(threshold + 1);
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   QuicByteCount new_threshold =
       QuicFlowControllerPeer::WindowUpdateThreshold(flow_controller_.get());
   EXPECT_GT(new_threshold, threshold);
 }
@@ skipping 46 matching lines @@
   EXPECT_TRUE(flow_controller_->UpdateHighestReceivedOffset(receive_offset));
   flow_controller_->AddBytesConsumed(threshold + 1);
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   QuicByteCount new_threshold =
       QuicFlowControllerPeer::WindowUpdateThreshold(flow_controller_.get());
   EXPECT_EQ(new_threshold, threshold);
 }
 
 TEST_F(QuicFlowControllerTest, ReceivingBytesNormalStableFlowWindow) {
   // This test will generate two WINDOW_UPDATE frames.
-  if (FLAGS_quic_reloadable_flag_quic_flow_control_faster_autotune) {
-    EXPECT_CALL(connection_, SendWindowUpdate(stream_id_, ::testing::_))
-        .Times(1);
-  } else {
-    EXPECT_CALL(connection_, SendWindowUpdate(stream_id_, ::testing::_))
-        .Times(2);
-  }
+  EXPECT_CALL(connection_, SendWindowUpdate(stream_id_, ::testing::_)).Times(1);
 
   Initialize();
   flow_controller_->set_auto_tune_receive_window(true);
 
   // Make sure clock is inititialized.
   connection_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
 
   QuicSentPacketManager* manager =
       QuicConnectionPeer::GetSentPacketManager(&connection_);
   RttStats* rtt_stats = const_cast<RttStats*>(manager->GetRttStats());
   rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(kRtt),
                        QuicTime::Delta::Zero(), QuicTime::Zero());
 
   EXPECT_FALSE(flow_controller_->IsBlocked());
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   EXPECT_EQ(kInitialSessionFlowControlWindowForTest,
             QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
 
   QuicByteCount threshold =
       QuicFlowControllerPeer::WindowUpdateThreshold(flow_controller_.get());
 
   QuicStreamOffset receive_offset = threshold + 1;
   // Receive some bytes, updating highest received offset, but not enough to
   // fill flow control receive window.
   EXPECT_TRUE(flow_controller_->UpdateHighestReceivedOffset(receive_offset));
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
   EXPECT_EQ(kInitialSessionFlowControlWindowForTest - receive_offset,
             QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
-  if (FLAGS_quic_reloadable_flag_quic_flow_control_faster_autotune) {
-    EXPECT_CALL(
-        session_flow_controller_,
-        EnsureWindowAtLeast(kInitialSessionFlowControlWindowForTest * 2 * 1.5));
-  }
+  EXPECT_CALL(
+      session_flow_controller_,
+      EnsureWindowAtLeast(kInitialSessionFlowControlWindowForTest * 2 * 1.5));
   flow_controller_->AddBytesConsumed(threshold + 1);
 
   // Result is that once again we have a fully open receive window.
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
-  if (FLAGS_quic_reloadable_flag_quic_flow_control_faster_autotune) {
-    EXPECT_EQ(
-        2 * kInitialSessionFlowControlWindowForTest,
-        QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
-  } else {
-    EXPECT_EQ(
-        kInitialSessionFlowControlWindowForTest,
-        QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
-  }
+  EXPECT_EQ(2 * kInitialSessionFlowControlWindowForTest,
+            QuicFlowControllerPeer::ReceiveWindowSize(flow_controller_.get()));
 
   // Move time forward, but by more than two RTTs.  Then receive and consume
   // some more, forcing a second WINDOW_UPDATE with unchanged max window size.
   connection_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2 * kRtt + 1));
 
   receive_offset += threshold + 1;
   EXPECT_TRUE(flow_controller_->UpdateHighestReceivedOffset(receive_offset));
 
   flow_controller_->AddBytesConsumed(threshold + 1);
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
 
   QuicByteCount new_threshold =
       QuicFlowControllerPeer::WindowUpdateThreshold(flow_controller_.get());
-  if (FLAGS_quic_reloadable_flag_quic_flow_control_faster_autotune) {
-    EXPECT_EQ(new_threshold, 2 * threshold);
-  } else {
-    EXPECT_EQ(new_threshold, threshold);
-  }
+  EXPECT_EQ(new_threshold, 2 * threshold);
 }
 
 TEST_F(QuicFlowControllerTest, ReceivingBytesNormalNoAutoTune) {
   // This test will generate two WINDOW_UPDATE frames.
   EXPECT_CALL(connection_, SendWindowUpdate(stream_id_, ::testing::_)).Times(2);
 
   Initialize();
   flow_controller_->set_auto_tune_receive_window(false);
 
   // Make sure clock is inititialized.
@@ skipping 39 matching lines @@
   EXPECT_FALSE(flow_controller_->FlowControlViolation());
 
   QuicByteCount new_threshold =
       QuicFlowControllerPeer::WindowUpdateThreshold(flow_controller_.get());
 
   EXPECT_EQ(new_threshold, threshold);
 }
 
 }  // namespace test
 }  // namespace net