Land Recent QUIC Changes.

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 19 matching lines @@
 using testing::WithArgs;
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
 
 const char kData1[] = "FooAndBar";
 const char kData2[] = "EepAndBaz";
 const size_t kDataLen = 9;
-const QuicConnectionId kStreamId = 3;
+const QuicStreamId kStreamId = 3;
 const bool kIsServer = true;
 const bool kShouldProcessData = true;
 
 class TestStream : public ReliableQuicStream {
  public:
   TestStream(QuicStreamId id,
              QuicSession* session,
              bool should_process_data)
       : ReliableQuicStream(id, session),
         should_process_data_(should_process_data) {}
@@ skipping 76 matching lines @@
         QuicSessionPeer::GetWriteblockedStreams(session_.get());
   }
 
   bool fin_sent() { return ReliableQuicStreamPeer::FinSent(stream_.get()); }
   bool rst_sent() { return ReliableQuicStreamPeer::RstSent(stream_.get()); }
 
   void set_initial_flow_control_window_bytes(uint32 val) {
     initial_flow_control_window_bytes_ = val;
   }
 
+  bool HasWriteBlockedStreams() {
+    return write_blocked_list_->HasWriteBlockedCryptoOrHeadersStream() ||
+           write_blocked_list_->HasWriteBlockedDataStreams();
+  }
+
  protected:
   MockConnection* connection_;
   scoped_ptr<MockSession> session_;
   scoped_ptr<TestStream> stream_;
   scoped_ptr<TestStream> stream2_;
   SpdyHeaderBlock headers_;
   QuicWriteBlockedList* write_blocked_list_;
   uint32 initial_flow_control_window_bytes_;
   QuicTime::Delta zero_;
   QuicVersionVector supported_versions_;
 };
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
   Initialize(kShouldProcessData);
 
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
           connection_->version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
           PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen, true)));
   stream_->WriteOrBufferData(kData1, false, NULL);
-  EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
+  EXPECT_FALSE(HasWriteBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, NoBlockingIfNoDataOrFin) {
   Initialize(kShouldProcessData);
 
   // Write no data and no fin.  If we consume nothing we should not be write
   // blocked.
   EXPECT_DFATAL(stream_->WriteOrBufferData(StringPiece(), false, NULL), "");
-  EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
+  EXPECT_FALSE(HasWriteBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, BlockIfOnlySomeDataConsumed) {
   Initialize(kShouldProcessData);
 
   // Write some data and no fin.  If we consume some but not all of the data,
   // we should be write blocked a not all the data was consumed.
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(1, false)));
   stream_->WriteOrBufferData(StringPiece(kData1, 2), false, NULL);
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
 
-
 TEST_F(ReliableQuicStreamTest, BlockIfFinNotConsumedWithData) {
   Initialize(kShouldProcessData);
 
   // Write some data and no fin.  If we consume all the data but not the fin,
   // we should be write blocked because the fin was not consumed.
   // (This should never actually happen as the fin should be sent out with the
   // last data)
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(2, false)));
   stream_->WriteOrBufferData(StringPiece(kData1, 2), true, NULL);
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, BlockIfSoloFinNotConsumed) {
   Initialize(kShouldProcessData);
 
   // Write no data and a fin.  If we consume nothing we should be write blocked,
   // as the fin was not consumed.
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(0, false)));
   stream_->WriteOrBufferData(StringPiece(), true, NULL);
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, WriteOrBufferData) {
   Initialize(kShouldProcessData);
 
-  EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
+  EXPECT_FALSE(HasWriteBlockedStreams());
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
           connection_->version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
           PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen - 1, false)));
   stream_->WriteOrBufferData(kData1, false, NULL);
-  EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
+  EXPECT_TRUE(HasWriteBlockedStreams());
 
   // Queue a bytes_consumed write.
   stream_->WriteOrBufferData(kData2, false, NULL);
 
   // Make sure we get the tail of the first write followed by the bytes_consumed
   InSequence s;
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).
       WillOnce(Return(QuicConsumedData(1, false)));
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).
       WillOnce(Return(QuicConsumedData(kDataLen - 2, false)));
@@ skipping 159 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) {
-    connection_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
+    session_->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_TRUE(HasWriteBlockedStreams());
 
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, proxy_delegate.get())).
       WillOnce(
           Return(QuicConsumedData(kSecondWriteSize, false)));
   stream_->OnCanWrite();
 
   // No ack expected for an empty write.
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, proxy_delegate.get())).
       WillOnce(
           Return(QuicConsumedData(0, false)));
@@ skipping 24 matching lines @@
       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) {
-    connection_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
+    session_->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());
+  EXPECT_TRUE(HasWriteBlockedStreams());
 
   // Handle the ack of the first write.
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
   proxy_delegate = NULL;
 
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
       WithArgs<4>(Invoke(CreateFunctor(
           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
       Return(QuicConsumedData(kDataSize - kInitialWriteSize, false))));
   stream_->OnCanWrite();
@@ skipping 10 matching lines @@
   scoped_refptr<MockAckNotifierDelegate> delegate(
       new StrictMock<MockAckNotifierDelegate>);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
       WithArgs<4>(Invoke(CreateFunctor(
           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
       Return(QuicConsumedData(kDataLen, true))));
   stream_->WriteOrBufferData(kData1, true, delegate.get());
-  EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
+  EXPECT_FALSE(HasWriteBlockedStreams());
 
   // Handle the ack.
   EXPECT_CALL(*delegate, OnAckNotification(1, 2, 3, 4, zero_));
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
 }
 
 // Verify delegate behavior when WriteOrBufferData buffers all the data.
 TEST_F(ReliableQuicStreamTest, BufferOnWriteAndBufferDataWithAckNotifer) {
   Initialize(kShouldProcessData);
 
   scoped_refptr<MockAckNotifierDelegate> delegate(
       new StrictMock<MockAckNotifierDelegate>);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(0, false)));
   stream_->WriteOrBufferData(kData1, true, delegate.get());
-  EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
+  EXPECT_TRUE(HasWriteBlockedStreams());
 
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
       WithArgs<4>(Invoke(CreateFunctor(
           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
       Return(QuicConsumedData(kDataLen, true))));
   stream_->OnCanWrite();
 
   // Handle the ack.
   EXPECT_CALL(*delegate, OnAckNotification(1, 2, 3, 4, zero_));
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
 }
 
 // Verify delegate behavior when WriteOrBufferData when the FIN is
 // sent out in a different packet.
 TEST_F(ReliableQuicStreamTest, WriteAndBufferDataWithAckNotiferOnlyFinRemains) {
   Initialize(kShouldProcessData);
 
   scoped_refptr<MockAckNotifierDelegate> delegate(
       new StrictMock<MockAckNotifierDelegate>);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
       WithArgs<4>(Invoke(CreateFunctor(
           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
       Return(QuicConsumedData(kDataLen, false))));
   stream_->WriteOrBufferData(kData1, true, delegate.get());
-  EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
+  EXPECT_TRUE(HasWriteBlockedStreams());
 
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(DoAll(
       WithArgs<4>(Invoke(CreateFunctor(
           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
       Return(QuicConsumedData(0, true))));
   stream_->OnCanWrite();
 
   // 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