Deprecate rolled out FLAGS_enable_quic_connection_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"
 #include "net/quic/quic_write_blocked_list.h"
 #include "net/quic/spdy_utils.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_flow_controller_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/test/gtest_util.h"
@@ skipping 444 matching lines @@
 
   const int kDataSize = 16 * 1024;
   const string kData(kDataSize, 'a');
 
   const int kFirstWriteSize = 100;
   const int kSecondWriteSize = 50;
   const int kLastWriteSize = kDataSize - kFirstWriteSize - kSecondWriteSize;
 
   // Set a large flow control send window so this doesn't interfere with test.
   stream_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
-  if (FLAGS_enable_quic_connection_flow_control_2) {
-    session_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
-  }
+  session_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
       .WillOnce(DoAll(WithArgs<5>(Invoke(CreateFunctor(
                           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
                       Return(QuicConsumedData(kFirstWriteSize, false))));
   stream_->WriteOrBufferData(kData, false, delegate.get());
   EXPECT_TRUE(HasWriteBlockedStreams());
 
@@ skipping 32 matching lines @@
   scoped_refptr<MockAckNotifierDelegate> delegate(
       new StrictMock<MockAckNotifierDelegate>);
 
   const int kDataSize = 16 * 1024;
   const string kData(kDataSize, 'a');
 
   const int kInitialWriteSize = 100;
 
   // Set a large flow control send window so this doesn't interfere with test.
   stream_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
-  if (FLAGS_enable_quic_connection_flow_control_2) {
-    session_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
-  }
+  session_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
       .WillOnce(DoAll(WithArgs<5>(Invoke(CreateFunctor(
                           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
                       Return(QuicConsumedData(kInitialWriteSize, false))));
   stream_->WriteOrBufferData(kData, false, delegate.get());
   EXPECT_TRUE(HasWriteBlockedStreams());
 
@@ skipping 85 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_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("."));
   EXPECT_GT(frame.offset, QuicFlowControllerPeer::ReceiveWindowOffset(
                               stream_->flow_controller()));
 
@@ skipping 24 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