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_connection.h"
 #include "net/quic/quic_spdy_compressor.h"
 #include "net/quic/quic_spdy_decompressor.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/spdy_utils.h"
+#include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::StringPiece;
 using std::min;
 using testing::_;
 using testing::InSequence;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrEq;
@@ skipping 49 matching lines @@
     connection_ = new testing::StrictMock<MockConnection>(
         kGuid, IPEndPoint(), kIsServer);
     session_.reset(new testing::StrictMock<MockSession>(
         connection_, kIsServer));
     stream_.reset(new TestStream(kStreamId, session_.get(),
                                  stream_should_process_data));
     stream2_.reset(new TestStream(kStreamId + 2, session_.get(),
                                  stream_should_process_data));
     compressor_.reset(new QuicSpdyCompressor());
     decompressor_.reset(new QuicSpdyDecompressor);
+    write_blocked_list_ =
+        QuicSessionPeer::GetWriteblockedStreams(session_.get());
   }
 
  protected:
   MockConnection* connection_;
   scoped_ptr<MockSession> session_;
   scoped_ptr<TestStream> stream_;
   scoped_ptr<TestStream> stream2_;
   scoped_ptr<QuicSpdyCompressor> compressor_;
   scoped_ptr<QuicSpdyDecompressor> decompressor_;
   SpdyHeaderBlock headers_;
+  BlockedList<QuicStreamId>* write_blocked_list_;
 };
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
   Initialize(kShouldProcessData);
 
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
-          1, PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP);
+          1, PACKET_8BYTE_GUID, !kIncludeVersion,
+          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   // TODO(rch): figure out how to get StrEq working here.
   //EXPECT_CALL(*session_, WriteData(kStreamId, StrEq(kData1), _, _)).WillOnce(
   EXPECT_CALL(*session_, WriteData(kStreamId, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen, true)));
   EXPECT_EQ(kDataLen, stream_->WriteData(kData1, false).bytes_consumed);
+  EXPECT_TRUE(write_blocked_list_->IsEmpty());
+}
+
+// TODO(rtenneti): Death tests crash on OS_ANDROID.
+#if GTEST_HAS_DEATH_TEST && !defined(NDEBUG) && !defined(OS_ANDROID)
+TEST_F(ReliableQuicStreamTest, NoBlockingIfNoDataOrFin) {
+  Initialize(kShouldProcessData);
+
+  // Write no data and no fin.  If we consume nothing we should not be write
+  // blocked.
+  EXPECT_DEBUG_DEATH({
+    EXPECT_CALL(*session_, WriteData(kStreamId, _, _, _)).WillOnce(
+        Return(QuicConsumedData(0, false)));
+    stream_->WriteData(StringPiece(), false);
+  EXPECT_TRUE(write_blocked_list_->IsEmpty());
+  }, "");
+}
+#endif  // GTEST_HAS_DEATH_TEST && !defined(NDEBUG) && !defined(OS_ANDROID)
+
+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_, WriteData(kStreamId, _, _, _)).WillOnce(
+      Return(QuicConsumedData(1, false)));
+  stream_->WriteData(StringPiece(kData1, 2), false);
+  ASSERT_EQ(1, write_blocked_list_->NumObjects());
+}
+
+
+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_, WriteData(kStreamId, _, _, _)).WillOnce(
+      Return(QuicConsumedData(2, false)));
+  stream_->WriteData(StringPiece(kData1, 2), true);
+  ASSERT_EQ(1, write_blocked_list_->NumObjects());
+}
+
+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_, WriteData(kStreamId, _, _, _)).WillOnce(
+      Return(QuicConsumedData(0, false)));
+  stream_->WriteData(StringPiece(), true);
+  ASSERT_EQ(1, write_blocked_list_->NumObjects());
 }
 
 TEST_F(ReliableQuicStreamTest, WriteData) {
   Initialize(kShouldProcessData);
 
+  EXPECT_TRUE(write_blocked_list_->IsEmpty());
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
-          1, PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP);
+          1, PACKET_8BYTE_GUID, !kIncludeVersion,
+          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   // TODO(rch): figure out how to get StrEq working here.
   //EXPECT_CALL(*session_, WriteData(_, StrEq(kData1), _, _)).WillOnce(
   EXPECT_CALL(*session_, WriteData(_, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen - 1, false)));
   // The return will be kDataLen, because the last byte gets buffered.
   EXPECT_EQ(kDataLen, stream_->WriteData(kData1, false).bytes_consumed);
+  EXPECT_FALSE(write_blocked_list_->IsEmpty());
 
   // Queue a bytes_consumed write.
   EXPECT_EQ(kDataLen, stream_->WriteData(kData2, false).bytes_consumed);
 
   // Make sure we get the tail of the first write followed by the bytes_consumed
   InSequence s;
   //EXPECT_CALL(*session_, WriteData(_, StrEq(&kData1[kDataLen - 1]), _, _)).
   EXPECT_CALL(*session_, WriteData(_, _, _, _)).
       WillOnce(Return(QuicConsumedData(1, false)));
   //EXPECT_CALL(*session_, WriteData(_, StrEq(kData2), _, _)).
@@ skipping 201 matching lines @@
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID))
       .Times(0);
   QuicStreamFrame frame2(stream_->id(), false, compressed_headers.length(),
                          "body data");
   stream_->OnStreamFrame(frame2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net