Removing deprecated flag FLAGS_enable_quic_stream_flow_control_2

net/quic/reliable_quic_stream_test.cc

 // Copyright (c) 2012 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/reliable_quic_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 377 matching lines @@
   EXPECT_TRUE(rst_sent());
 
   // Now close the stream (any further resets being sent would break the
   // expectation above).
   stream_->OnClose();
   EXPECT_FALSE(fin_sent());
   EXPECT_TRUE(rst_sent());
 }
 
 TEST_F(ReliableQuicStreamTest, StreamFlowControlMultipleWindowUpdates) {
-  ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true);
   set_initial_flow_control_window_bytes(1000);
 
   Initialize(kShouldProcessData);
 
   // If we receive multiple WINDOW_UPDATES (potentially out of order), then we
   // want to make sure we latch the largest offset we see.
 
   // Initially should be default.
   EXPECT_EQ(
       initial_flow_control_window_bytes_,
@@ skipping 15 matching lines @@
   stream_->OnWindowUpdateFrame(window_update_3);
   stream_->OnWindowUpdateFrame(window_update_4);
   EXPECT_EQ(
       window_update_3.byte_offset,
       QuicFlowControllerPeer::SendWindowOffset(stream_->flow_controller()));
 }
 
 TEST_F(ReliableQuicStreamTest, StreamFlowControlShouldNotBlockInLessThanQ017) {
   // TODO(rjshade): Remove this test when we no longer have any versions <
   //                QUIC_VERSION_17.
-  ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true);
 
   // Make sure we are using a version which does not support flow control.
   QuicVersion kTestQuicVersions[] = {QUIC_VERSION_16};
   QuicVersionVector versions;
   for (size_t i = 0; i < arraysize(kTestQuicVersions); ++i) {
     versions.push_back(kTestQuicVersions[i]);
   }
   set_supported_versions(versions);
 
   // Peer is not talking QUIC_VERSION_17 so assumes that it can send a zero
@@ skipping 184 matching lines @@
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
   EXPECT_CALL(*delegate, OnAckNotification(11, 22, 33, 44, zero_));
   proxy_delegate->OnAckNotification(10, 20, 30, 40, zero_);
 }
 
 // Verify that when we receive a packet which violates flow control (i.e. sends
 // too much data on the stream) that the stream sequencer never sees this frame,
 // as we check for violation and close the connection early.
 TEST_F(ReliableQuicStreamTest,
        StreamSequencerNeverSeesPacketsViolatingFlowControl) {
-  ValueRestore<bool> old_stream_flag(
-      &FLAGS_enable_quic_stream_flow_control_2, true);
   ValueRestore<bool> old_connection_flag(
       &FLAGS_enable_quic_connection_flow_control_2, true);
 
   Initialize(kShouldProcessData);
 
   // Receive a stream frame that violates flow control: the byte offset is
   // higher than the receive window offset.
   QuicStreamFrame frame(stream_->id(), false,
                         kInitialSessionFlowControlWindowForTest + 1,
                         MakeIOVector("."));
@@ skipping 27 matching lines @@
 
   EXPECT_FALSE(stream_->HasFinalReceivedByteOffset());
   QuicRstStreamFrame rst_frame(stream_->id(), QUIC_STREAM_CANCELLED, 1234);
   stream_->OnStreamReset(rst_frame);
   EXPECT_TRUE(stream_->HasFinalReceivedByteOffset());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net