Merge ReliableQuicStream::WriteData with

net/quic/reliable_quic_stream_test.cc

Index: net/quic/reliable_quic_stream_test.cc
diff --git a/net/quic/reliable_quic_stream_test.cc b/net/quic/reliable_quic_stream_test.cc
index bfbe9c7c0fe9b951bf16f2113e6963480fbda013..a8bd5c917d50641645f3de2ba748ae47986575ee 100644
--- a/net/quic/reliable_quic_stream_test.cc
+++ b/net/quic/reliable_quic_stream_test.cc
@@ -50,7 +50,7 @@ class TestStream : public ReliableQuicStream {
     return should_process_data_ ? data_len : 0;
   }
 
-  using ReliableQuicStream::WriteData;
+  using ReliableQuicStream::WriteOrBufferData;
   using ReliableQuicStream::CloseReadSide;
   using ReliableQuicStream::CloseWriteSide;
 
@@ -128,7 +128,7 @@ TEST_F(ReliableQuicStreamTest, WriteAllData) {
           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());
 }
 
@@ -142,7 +142,7 @@ TEST_F(ReliableQuicStreamTest, NoBlockingIfNoDataOrFin) {
   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());
   }, "");
 }
@@ -155,7 +155,7 @@ TEST_F(ReliableQuicStreamTest, BlockIfOnlySomeDataConsumed) {
   // 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());
 }
 
@@ -169,7 +169,7 @@ TEST_F(ReliableQuicStreamTest, BlockIfFinNotConsumedWithData) {
   // 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());
 }
 
@@ -180,11 +180,11 @@ TEST_F(ReliableQuicStreamTest, BlockIfSoloFinNotConsumed) {
   // 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());
@@ -194,12 +194,11 @@ TEST_F(ReliableQuicStreamTest, WriteData) {
           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;