Rename FLAGS_enable_quic_connection_flow_control to FLAGS_enable_quic_connection_flow_control_2, an…

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 381 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) {
+  if (FLAGS_enable_quic_connection_flow_control_2) {
     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());
@@ skipping 34 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) {
+  if (FLAGS_enable_quic_connection_flow_control_2) {
     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());
@@ skipping 90 matching lines @@
 }
 
 // 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, true);
+      &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,
                         kInitialFlowControlWindowForTest + 1,
                         MakeIOVector("."));
   EXPECT_GT(frame.offset, QuicFlowControllerPeer::ReceiveWindowOffset(
                               stream_->flow_controller()));
@@ skipping 25 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