Merge ReliableQuicStream::WriteData with

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_spdy_compressor.h"
 #include "net/quic/quic_spdy_decompressor.h"
@@ skipping 32 matching lines @@
       : ReliableQuicStream(id, session),
         should_process_data_(should_process_data) {}
 
   virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
     EXPECT_NE(0u, data_len);
     DVLOG(1) << "ProcessData data_len: " << data_len;
     data_ += string(data, data_len);
     return should_process_data_ ? data_len : 0;
   }
 
-  using ReliableQuicStream::WriteData;
+  using ReliableQuicStream::WriteOrBufferData;
   using ReliableQuicStream::CloseReadSide;
   using ReliableQuicStream::CloseWriteSide;
 
   const string& data() const { return data_; }
 
  private:
   bool should_process_data_;
   string data_;
 };
 
@@ skipping 57 matching lines @@
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
   Initialize(kShouldProcessData);
 
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
           connection_->version(), PACKET_8BYTE_GUID, !kIncludeVersion,
           PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   EXPECT_CALL(*session_, WritevData(kStreamId, _, 1, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen, true)));
-  EXPECT_EQ(kDataLen, stream_->WriteData(kData1, false).bytes_consumed);
+  stream_->WriteOrBufferData(kData1, false);
   EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
 }
 
 // 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_, WritevData(kStreamId, _, 1, _, _, _)).WillOnce(
         Return(QuicConsumedData(0, false)));
-    stream_->WriteData(StringPiece(), false);
+    stream_->WriteOrBufferData(StringPiece(), false);
     EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
   }, "");
 }
 #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_, WritevData(kStreamId, _, 1, _, _, _)).WillOnce(
       Return(QuicConsumedData(1, false)));
-  stream_->WriteData(StringPiece(kData1, 2), false);
+  stream_->WriteOrBufferData(StringPiece(kData1, 2), false);
   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, _, 1, _, _, _)).WillOnce(
       Return(QuicConsumedData(2, false)));
-  stream_->WriteData(StringPiece(kData1, 2), true);
+  stream_->WriteOrBufferData(StringPiece(kData1, 2), true);
   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, _, 1, _, _, _)).WillOnce(
       Return(QuicConsumedData(0, false)));
-  stream_->WriteData(StringPiece(), true);
+  stream_->WriteOrBufferData(StringPiece(), true);
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
 
-TEST_F(ReliableQuicStreamTest, WriteData) {
+TEST_F(ReliableQuicStreamTest, WriteOrBufferData) {
   Initialize(kShouldProcessData);
 
   EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
           connection_->version(), PACKET_8BYTE_GUID, !kIncludeVersion,
           PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   EXPECT_CALL(*session_, WritevData(_, _, 1, _, _, _)).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);
+  stream_->WriteOrBufferData(kData1, false);
   EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
 
   // Queue a bytes_consumed write.
-  EXPECT_EQ(kDataLen, stream_->WriteData(kData2, false).bytes_consumed);
+  stream_->WriteOrBufferData(kData2, false);
 
   // Make sure we get the tail of the first write followed by the bytes_consumed
   InSequence s;
   EXPECT_CALL(*session_, WritevData(_, _, 1, _, _, _)).
       WillOnce(Return(QuicConsumedData(1, false)));
   EXPECT_CALL(*session_, WritevData(_, _, 1, _, _, _)).
       WillOnce(Return(QuicConsumedData(kDataLen - 2, false)));
   stream_->OnCanWrite();
 
   // And finally the end of the bytes_consumed.
@@ skipping 344 matching lines @@
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID))
       .Times(0);
   QuicStreamFrame frame2(stream_->id(), false, compressed_headers.length(),
                          MakeIOVector("body data"));
   stream_->OnStreamFrame(frame2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net