Remove FEC from send path.

net/tools/quic/quic_simple_server_stream_test.cc

 // Copyright (c) 2013 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/tools/quic/quic_simple_server_stream.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
@@ skipping 75 matching lines @@
 
   explicit MockQuicSimpleServerSession(QuicConnection* connection,
                                        MockQuicServerSessionVisitor* owner,
                                        QuicCryptoServerConfig* crypto_config)
       : QuicSimpleServerSession(::net::test::DefaultQuicConfig(),
                                 connection,
                                 owner,
                                 crypto_config) {
     set_max_open_incoming_streams(kMaxStreamsForTest);
     set_max_open_outgoing_streams(kMaxStreamsForTest);
-    ON_CALL(*this, WritevData(_, _, _, _, _, _))
+    ON_CALL(*this, WritevData(_, _, _, _, _))
         .WillByDefault(testing::Return(QuicConsumedData(0, false)));
   }
 
   ~MockQuicSimpleServerSession() override {}
 
   MOCK_METHOD2(OnConnectionClosed,
                void(QuicErrorCode error, ConnectionCloseSource source));
   MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id));
-  MOCK_METHOD6(WritevData,
+  MOCK_METHOD5(WritevData,
                QuicConsumedData(QuicStreamId id,
                                 QuicIOVector data,
                                 QuicStreamOffset offset,
                                 bool fin,
-                                FecProtection fec_protection,
                                 QuicAckListenerInterface*));
   MOCK_METHOD2(OnStreamHeaders,
                void(QuicStreamId stream_id, StringPiece headers_data));
   MOCK_METHOD2(OnStreamHeadersPriority,
                void(QuicStreamId stream_id, SpdyPriority priority));
   MOCK_METHOD3(OnStreamHeadersComplete,
                void(QuicStreamId stream_id, bool fin, size_t frame_len));
   MOCK_METHOD5(WriteHeaders,
                size_t(QuicStreamId id,
                       const SpdyHeaderBlock& headers,
@@ skipping 81 matching lines @@
   QuicSimpleServerStreamPeer* stream_;  // Owned by session_.
   string headers_string_;
   string body_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicSimpleServerStreamTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicSimpleServerStreamTest, TestFraming) {
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(MockQuicSpdySession::ConsumeAllData));
   stream_->OnStreamHeaders(headers_string_);
   stream_->OnStreamHeadersComplete(false, headers_string_.size());
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
   EXPECT_EQ("/", StreamHeadersValue(":path"));
   EXPECT_EQ("POST", StreamHeadersValue(":method"));
   EXPECT_EQ(body_, StreamBody());
 }
 
 TEST_P(QuicSimpleServerStreamTest, TestFramingOnePacket) {
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(MockQuicSpdySession::ConsumeAllData));
 
   stream_->OnStreamHeaders(headers_string_);
   stream_->OnStreamHeadersComplete(false, headers_string_.size());
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
   EXPECT_EQ("/", StreamHeadersValue(":path"));
   EXPECT_EQ("POST", StreamHeadersValue(":method"));
   EXPECT_EQ(body_, StreamBody());
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorInStopReading) {
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(MockQuicSpdySession::ConsumeAllData));
 
   EXPECT_FALSE(stream_->fin_received());
   EXPECT_FALSE(stream_->rst_received());
 
   stream_->set_fin_sent(true);
   stream_->CloseWriteSide();
 
   if (GetParam() > QUIC_VERSION_28) {
     EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1);
   } else {
     EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
   }
   stream_->StopReading();
 }
 
 TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) {
   string large_body = "hello world!!!!!!";
 
   // We'll automatically write out an error (headers + body)
   EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _));
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .WillOnce(Invoke(MockQuicSpdySession::ConsumeAllData));
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   stream_->OnStreamHeaders(headers_string_);
   stream_->OnStreamHeadersComplete(false, headers_string_.size());
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_));
   // Content length is still 11.  This will register as an error and we won't
   // accept the bytes.
   stream_->OnStreamFrame(
@@ skipping 16 matching lines @@
   response_headers_[":status"] = "200 OK";
   response_headers_["content-length"] = "5";
   string body = "Yummm";
   QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar",
                                                 response_headers_, body);
 
   stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr));
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(
           strlen(QuicSimpleServerStream::kErrorResponseBody), true)));
 
   QuicSimpleServerStreamPeer::SendResponse(stream_);
   EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
@@ skipping 36 matching lines @@
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "200";
   response_headers_["content-length"] = "5";
   string body = "Yummm";
   QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar",
                                                 response_headers_, body);
   stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr));
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(body.length(), true)));
 
   QuicSimpleServerStreamPeer::SendResponse(stream_);
   EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendReponseWithPushResources) {
@@ skipping 18 matching lines @@
   (*request_headers)[":authority"] = host;
   (*request_headers)[":version"] = "HTTP/1.1";
   (*request_headers)[":method"] = "GET";
 
   stream_->set_fin_received(true);
   InSequence s;
   EXPECT_CALL(session_, PromisePushResources(host + request_path, _,
                                              ::net::test::kClientDataStreamId1,
                                              *request_headers));
   EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr));
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(body.length(), true)));
   QuicSimpleServerStreamPeer::SendResponse(stream_);
 }
 
 TEST_P(QuicSimpleServerStreamTest, PushResponseOnClientInitiatedStream) {
   // Calling PushResponse() on a client initialted stream is never supposed to
   // happen.
   SpdyHeaderBlock headers;
   EXPECT_DFATAL(stream_->PushResponse(headers),
@@ skipping 25 matching lines @@
   response_headers_["content-length"] = "5";
   const string kBody = "Hello";
   QuicInMemoryCache::GetInstance()->AddResponse(kHost, kPath, response_headers_,
                                                 kBody);
 
   // Call PushResponse() should trigger stream to fetch response from cache
   // and send it back.
   EXPECT_CALL(session_,
               WriteHeaders(kServerInitiatedStreamId, _, false,
                            server_initiated_stream->priority(), nullptr));
-  EXPECT_CALL(session_, WritevData(kServerInitiatedStreamId, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(kServerInitiatedStreamId, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(kBody.size(), true)));
   server_initiated_stream->PushResponse(headers);
   EXPECT_EQ(kPath, QuicSimpleServerStreamPeer::headers(
                        server_initiated_stream)[":path"]
                        .as_string());
   EXPECT_EQ("GET", QuicSimpleServerStreamPeer::headers(
                        server_initiated_stream)[":method"]
                        .as_string());
 }
 
 TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) {
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "500 Server Error";
   response_headers_["content-length"] = "3";
   stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _));
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(3, true)));
 
   QuicSimpleServerStreamPeer::SendErrorResponse(stream_);
   EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) {
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   SpdyHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
   request_headers["content-length"] = StringPiece("11\00012", 5);
 
   headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers);
 
   EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _));
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(MockQuicSpdySession::ConsumeAllData));
   stream_->OnStreamHeaders(headers_string_);
   stream_->OnStreamHeadersComplete(true, headers_string_.size());
 
   EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 TEST_P(QuicSimpleServerStreamTest, InvalidLeadingNullContentLength) {
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   SpdyHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
   request_headers["content-length"] = StringPiece("\00012", 3);
 
   headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers);
 
   EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _));
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(MockQuicSpdySession::ConsumeAllData));
   stream_->OnStreamHeaders(headers_string_);
   stream_->OnStreamHeadersComplete(true, headers_string_.size());
 
   EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
@@ skipping 13 matching lines @@
   EXPECT_FALSE(stream_->write_side_closed());
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorWithEarlyResponse) {
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "500 Server Error";
   response_headers_["content-length"] = "3";
 
   InSequence s;
   EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, _, _, _));
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(3, true)));
   if (GetParam() > QUIC_VERSION_28) {
     EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1);
   } else {
     EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
   }
   EXPECT_FALSE(stream_->fin_received());
   QuicSimpleServerStreamPeer::SendErrorResponse(stream_);
   EXPECT_TRUE(stream_->reading_stopped());
@@ skipping 44 matching lines @@
   };
   StringPiece data(arr, arraysize(arr));
   QuicStreamFrame frame(stream_->id(), true, 0, data);
   // Verify that we don't crash when we get a invalid headers in stream frame.
   stream_->OnStreamFrame(frame);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net