API changes to Write path Session on down for FEC protection.

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 139 matching lines @@
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
   Initialize(kShouldProcessData);
 
   size_t length = 1 + QuicPacketCreator::StreamFramePacketOverhead(
       connection_->version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
       PACKET_6BYTE_SEQUENCE_NUMBER, 0u, NOT_IN_FEC_GROUP);
   QuicConnectionPeer::GetPacketCreator(connection_)->set_max_packet_length(
       length);
 
-  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _)).WillOnce(
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen, true)));
   stream_->WriteOrBufferData(kData1, false, NULL);
   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(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(kHeadersStreamId, _, _, _, _))
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
       .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(kHeadersStreamId, _, _, _, _))
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
       .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(kHeadersStreamId, _, _, _, _))
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
       .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(HasWriteBlockedStreams());
   size_t length = 1 + QuicPacketCreator::StreamFramePacketOverhead(
       connection_->version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
       PACKET_6BYTE_SEQUENCE_NUMBER, 0u, NOT_IN_FEC_GROUP);
   QuicConnectionPeer::GetPacketCreator(connection_)->set_max_packet_length(
       length);
 
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).WillOnce(
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen - 1, false)));
   stream_->WriteOrBufferData(kData1, false, NULL);
   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(_, _, _, _, _)).
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).
       WillOnce(Return(QuicConsumedData(1, false)));
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).
       WillOnce(Return(QuicConsumedData(kDataLen - 2, false)));
   stream_->OnCanWrite();
 
   // And finally the end of the bytes_consumed.
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).
       WillOnce(Return(QuicConsumedData(2, true)));
   stream_->OnCanWrite();
 }
 
 TEST_F(ReliableQuicStreamTest, ConnectionCloseAfterStreamClose) {
   Initialize(kShouldProcessData);
 
   stream_->CloseReadSide();
   stream_->CloseWriteSide();
   EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
   EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
   stream_->OnConnectionClosed(QUIC_INTERNAL_ERROR, false);
   EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
   EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
 }
 
 TEST_F(ReliableQuicStreamTest, RstAlwaysSentIfNoFinSent) {
   // For flow control accounting, a stream must send either a FIN or a RST frame
   // before termination.
   // Test that if no FIN has been sent, we send a RST.
 
   Initialize(kShouldProcessData);
   EXPECT_FALSE(fin_sent());
   EXPECT_FALSE(rst_sent());
 
   // Write some data, with no FIN.
-  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _))
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(1, false)));
   stream_->WriteOrBufferData(StringPiece(kData1, 1), false, NULL);
   EXPECT_FALSE(fin_sent());
   EXPECT_FALSE(rst_sent());
 
   // Now close the stream, and expect that we send a RST.
   EXPECT_CALL(*session_, SendRstStream(_, _, _));
   stream_->OnClose();
   EXPECT_FALSE(fin_sent());
   EXPECT_TRUE(rst_sent());
 }
 
 TEST_F(ReliableQuicStreamTest, RstNotSentIfFinSent) {
   // For flow control accounting, a stream must send either a FIN or a RST frame
   // before termination.
   // Test that if a FIN has been sent, we don't also send a RST.
 
   Initialize(kShouldProcessData);
   EXPECT_FALSE(fin_sent());
   EXPECT_FALSE(rst_sent());
 
   // Write some data, with FIN.
-  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _))
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(1, true)));
   stream_->WriteOrBufferData(StringPiece(kData1, 1), true, NULL);
   EXPECT_TRUE(fin_sent());
   EXPECT_FALSE(rst_sent());
 
   // Now close the stream, and expect that we do not send a RST.
   stream_->OnClose();
   EXPECT_TRUE(fin_sent());
   EXPECT_FALSE(rst_sent());
 }
@@ skipping 100 matching lines @@
   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) {
     session_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
   }
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
-  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _))
-      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<5>(Invoke(CreateFunctor(
                           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
                       Return(QuicConsumedData(kFirstWriteSize, false))));
   stream_->WriteOrBufferData(kData, false, delegate.get());
   EXPECT_TRUE(HasWriteBlockedStreams());
 
   EXPECT_CALL(*session_,
-              WritevData(kHeadersStreamId, _, _, _, proxy_delegate.get()))
+              WritevData(kHeadersStreamId, _, _, _, _, proxy_delegate.get()))
       .WillOnce(Return(QuicConsumedData(kSecondWriteSize, false)));
   stream_->OnCanWrite();
 
   // No ack expected for an empty write.
   EXPECT_CALL(*session_,
-              WritevData(kHeadersStreamId, _, _, _, proxy_delegate.get()))
+              WritevData(kHeadersStreamId, _, _, _, _, proxy_delegate.get()))
       .WillOnce(Return(QuicConsumedData(0, false)));
   stream_->OnCanWrite();
 
   EXPECT_CALL(*session_,
-              WritevData(kHeadersStreamId, _, _, _, proxy_delegate.get()))
+              WritevData(kHeadersStreamId, _, _, _, _, proxy_delegate.get()))
       .WillOnce(Return(QuicConsumedData(kLastWriteSize, false)));
   stream_->OnCanWrite();
 
   // There were two writes, so OnAckNotification is not propagated
   // until the third Ack arrives.
   proxy_delegate->OnAckNotification(1, 2, 3, 4, zero_);
   proxy_delegate->OnAckNotification(10, 20, 30, 40, zero_);
 
   // The arguments to delegate->OnAckNotification are the sum of the
   // arguments to proxy_delegate OnAckNotification calls.
@@ skipping 15 matching lines @@
   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) {
     session_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
   }
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
-  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _))
-      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<5>(Invoke(CreateFunctor(
                           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
                       Return(QuicConsumedData(kInitialWriteSize, false))));
   stream_->WriteOrBufferData(kData, false, delegate.get());
   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(kHeadersStreamId, _, _, _, _)).WillOnce(
-      DoAll(WithArgs<4>(Invoke(CreateFunctor(
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _)).WillOnce(
+      DoAll(WithArgs<5>(Invoke(CreateFunctor(
                 &SaveProxyAckNotifierDelegate, &proxy_delegate))),
             Return(QuicConsumedData(kDataSize - kInitialWriteSize, false))));
   stream_->OnCanWrite();
 
   // Handle the ack for the second write.
   EXPECT_CALL(*delegate, OnAckNotification(101, 202, 303, 404, zero_));
   proxy_delegate->OnAckNotification(100, 200, 300, 400, zero_);
 }
 
 // Verify delegate behavior when WriteOrBufferData does not buffer.
 TEST_F(ReliableQuicStreamTest, WriteAndBufferDataWithAckNotiferNoBuffer) {
   Initialize(kShouldProcessData);
 
   scoped_refptr<MockAckNotifierDelegate> delegate(
       new StrictMock<MockAckNotifierDelegate>);
 
   scoped_refptr<QuicAckNotifier::DelegateInterface> proxy_delegate;
 
-  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _))
-      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<5>(Invoke(CreateFunctor(
                           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
                       Return(QuicConsumedData(kDataLen, true))));
   stream_->WriteOrBufferData(kData1, true, delegate.get());
   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(kHeadersStreamId, _, _, _, _))
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(0, false)));
   stream_->WriteOrBufferData(kData1, true, delegate.get());
   EXPECT_TRUE(HasWriteBlockedStreams());
 
-  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _))
-      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<5>(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(kHeadersStreamId, _, _, _, _))
-      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<5>(Invoke(CreateFunctor(
                           &SaveProxyAckNotifierDelegate, &proxy_delegate))),
                       Return(QuicConsumedData(kDataLen, false))));
   stream_->WriteOrBufferData(kData1, true, delegate.get());
   EXPECT_TRUE(HasWriteBlockedStreams());
 
-  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _))
-      .WillOnce(DoAll(WithArgs<4>(Invoke(CreateFunctor(
+  EXPECT_CALL(*session_, WritevData(kHeadersStreamId, _, _, _, _, _))
+      .WillOnce(DoAll(WithArgs<5>(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_);
 }
 
@@ skipping 44 matching lines @@
 
   EXPECT_FALSE(stream_->HasFinalReceivedByteOffset());
   QuicRstStreamFrame rst_frame(stream_->id(), QUIC_STREAM_CANCELLED, 1234);
   stream_->OnStreamReset(rst_frame);
   EXPECT_TRUE(stream_->HasFinalReceivedByteOffset());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net