Removing deprecated flag FLAGS_enable_quic_stream_flow_control_2

net/quic/quic_data_stream_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_data_stream.h"
 
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
@@ skipping 267 matching lines @@
     ASSERT_EQ(data.data()[i + 1], buffer2[0]) << i;
   }
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlBlocked) {
   // Tests that we send a BLOCKED frame to the peer when we attempt to write,
   // but are flow control blocked.
   if (GetParam() < QUIC_VERSION_17) {
     return;
   }
-  ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true);
 
   Initialize(kShouldProcessData);
 
   // Set a small flow control limit.
   const uint64 kWindow = 36;
   QuicFlowControllerPeer::SetSendWindowOffset(stream_->flow_controller(),
                                               kWindow);
   EXPECT_EQ(kWindow, QuicFlowControllerPeer::SendWindowOffset(
                          stream_->flow_controller()));
 
@@ skipping 18 matching lines @@
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) {
   // The flow control receive window decreases whenever we add new bytes to the
   // sequencer, whether they are consumed immediately or buffered. However we
   // only send WINDOW_UPDATE frames based on increasing number of bytes
   // consumed.
   if (GetParam() < QUIC_VERSION_17) {
     return;
   }
-  ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true);
 
   // Don't process data - it will be buffered instead.
   Initialize(!kShouldProcessData);
 
   // Expect no WINDOW_UPDATE frames to be sent.
   EXPECT_CALL(*connection_, SendWindowUpdate(_, _)).Times(0);
 
   // Set a small flow control receive window.
   const uint64 kWindow = 36;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
@@ skipping 27 matching lines @@
       QuicFlowControllerPeer::ReceiveWindowSize(stream_->flow_controller()));
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlWindowUpdate) {
   // Tests that on receipt of data, the stream updates its receive window offset
   // appropriately, and sends WINDOW_UPDATE frames when its receive window drops
   // too low.
   if (GetParam() < QUIC_VERSION_17) {
     return;
   }
-  ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true);
 
   Initialize(kShouldProcessData);
 
   // Set a small flow control limit.
   const uint64 kWindow = 36;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kWindow);
   QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(),
                                               kWindow);
   EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowOffset(
@@ skipping 28 matching lines @@
                          stream_->flow_controller()));
 }
 
 TEST_P(QuicDataStreamTest, ConnectionFlowControlWindowUpdate) {
   // Tests that on receipt of data, the connection updates its receive window
   // offset appropriately, and sends WINDOW_UPDATE frames when its receive
   // window drops too low.
   if (GetParam() < QUIC_VERSION_19) {
     return;
   }
-  ValueRestore<bool> old_flag2(&FLAGS_enable_quic_stream_flow_control_2, true);
   ValueRestore<bool> old_flag(&FLAGS_enable_quic_connection_flow_control_2,
                               true);
 
   Initialize(kShouldProcessData);
 
   // Set a small flow control limit for streams and connection.
   const uint64 kWindow = 36;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kWindow);
   QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(),
@@ skipping 36 matching lines @@
                          MakeIOVector("a"));
   stream_->OnStreamFrame(frame3);
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlViolation) {
   // Tests that on if the peer sends too much data (i.e. violates the flow
   // control protocol), then we terminate the connection.
   if (GetParam() < QUIC_VERSION_17) {
     return;
   }
-  ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true);
 
   // Stream should not process data, so that data gets buffered in the
   // sequencer, triggering flow control limits.
   Initialize(!kShouldProcessData);
 
   // Set a small flow control limit.
   const uint64 kWindow = 50;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kWindow);
 
@@ skipping 11 matching lines @@
   stream_->OnStreamFrame(frame);
 }
 
 TEST_P(QuicDataStreamTest, ConnectionFlowControlViolation) {
   // Tests that on if the peer sends too much data (i.e. violates the flow
   // control protocol), at the connection level (rather than the stream level)
   // then we terminate the connection.
   if (GetParam() < QUIC_VERSION_19) {
     return;
   }
-  ValueRestore<bool> old_flag2(&FLAGS_enable_quic_stream_flow_control_2, true);
   ValueRestore<bool> old_flag(&FLAGS_enable_quic_connection_flow_control_2,
                               true);
 
   // Stream should not process data, so that data gets buffered in the
   // sequencer, triggering flow control limits.
   Initialize(!kShouldProcessData);
 
   // Set a small flow control window on streams, and connection.
   const uint64 kStreamWindow = 50;
   const uint64 kConnectionWindow = 10;
@@ skipping 17 matching lines @@
               SendConnectionClose(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA));
   stream_->OnStreamFrame(frame);
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlFinNotBlocked) {
   // An attempt to write a FIN with no data should not be flow control blocked,
   // even if the send window is 0.
   if (GetParam() < QUIC_VERSION_17) {
     return;
   }
-  ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true);
 
   Initialize(kShouldProcessData);
 
   // Set a flow control limit of zero.
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), 0);
   EXPECT_EQ(0u, QuicFlowControllerPeer::ReceiveWindowOffset(
                     stream_->flow_controller()));
 
   // Send a frame with a FIN but no data. This should not be blocked.
   string body = "";
   bool fin = true;
 
   EXPECT_CALL(*connection_, SendBlocked(kClientDataStreamId1)).Times(0);
   EXPECT_CALL(*session_, WritevData(kClientDataStreamId1, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(0, fin)));
 
   stream_->WriteOrBufferData(body, fin, NULL);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net