Pull out flow control functionality from ReliableQuicStream into a new

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_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"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 
 using base::StringPiece;
 using std::min;
 using testing::_;
@@ skipping 28 matching lines @@
     EXPECT_NE(0u, data_len);
     DVLOG(1) << "ProcessData data_len: " << data_len;
     data_ += string(data, data_len);
     return should_process_data_ ? data_len : 0;
   }
 
   virtual QuicPriority EffectivePriority() const OVERRIDE {
     return QuicUtils::HighestPriority();
   }
 
-  virtual bool IsFlowControlEnabled() const OVERRIDE {
-    return true;
-  }
-
   using ReliableQuicStream::WriteOrBufferData;
   using ReliableQuicStream::CloseReadSide;
   using ReliableQuicStream::CloseWriteSide;
   using ReliableQuicStream::OnClose;
 
  private:
   bool should_process_data_;
   string data_;
 };
 
@@ skipping 239 matching lines @@
   ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control, 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_,
-            ReliableQuicStreamPeer::SendWindowOffset(stream_.get()));
+            QuicFlowControllerPeer::SendWindowOffset(
+                stream_.get()->flow_controller()));
 
   // Check a single WINDOW_UPDATE results in correct offset.
   QuicWindowUpdateFrame window_update_1(stream_->id(), 1234);
   stream_->OnWindowUpdateFrame(window_update_1);
   EXPECT_EQ(window_update_1.byte_offset,
-            ReliableQuicStreamPeer::SendWindowOffset(stream_.get()));
+            QuicFlowControllerPeer::SendWindowOffset(
+                stream_.get()->flow_controller()));
 
   // Now send a few more WINDOW_UPDATES and make sure that only the largest is
   // remembered.
   QuicWindowUpdateFrame window_update_2(stream_->id(), 1);
   QuicWindowUpdateFrame window_update_3(stream_->id(), 9999);
   QuicWindowUpdateFrame window_update_4(stream_->id(), 5678);
   stream_->OnWindowUpdateFrame(window_update_2);
   stream_->OnWindowUpdateFrame(window_update_3);
   stream_->OnWindowUpdateFrame(window_update_4);
   EXPECT_EQ(window_update_3.byte_offset,
-            ReliableQuicStreamPeer::SendWindowOffset(stream_.get()));
+            QuicFlowControllerPeer::SendWindowOffset(
+                stream_.get()->flow_controller()));
 }
 
 void SaveProxyAckNotifierDelegate(
     scoped_refptr<QuicAckNotifier::DelegateInterface>* delegate_out,
     QuicAckNotifier::DelegateInterface* delegate) {
   *delegate_out = delegate;
 }
 TEST_F(ReliableQuicStreamTest, WriteOrBufferDataWithQuicAckNotifier) {
   Initialize(kShouldProcessData);
 
   scoped_refptr<MockAckNotifierDelegate> delegate(
       new StrictMock<MockAckNotifierDelegate>);
 
   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);
+
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
       WithArgs<4>(Invoke(CreateFunctor(
           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
       Return(QuicConsumedData(kFirstWriteSize, false))));
   stream_->WriteOrBufferData(kData, false, delegate.get());
   EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
 
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, proxy_delegate.get())).
@@ skipping 29 matching lines @@
   Initialize(kShouldProcessData);
 
   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);
+
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
       WithArgs<4>(Invoke(CreateFunctor(
           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
       Return(QuicConsumedData(kInitialWriteSize, false))));
   stream_->WriteOrBufferData(kData, false, delegate.get());
   EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
 
   // Handle the ack of the first write.
@@ skipping 82 matching lines @@
 
   // Handle the acks.
   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_);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net