Land Recent QUIC Changes.

net/tools/quic/quic_reliable_server_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/tools/quic/quic_reliable_server_stream.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/quic_spdy_compressor.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ skipping 104 matching lines @@
   }
 
   BalsaHeaders response_headers_;
   EpollServer eps_;
   StrictMock<MockSession> session_;
   scoped_ptr<QuicReliableServerStream> stream_;
   string headers_string_;
   string body_;
 };
 
-QuicConsumedData ConsumeAllData(QuicStreamId id,
-                                const struct iovec* iov,
-                                int iov_count,
-                                QuicStreamOffset offset,
-                                bool fin) {
+QuicConsumedData ConsumeAllData(
+    QuicStreamId id,
+    const struct iovec* iov,
+    int iov_count,
+    QuicStreamOffset offset,
+    bool fin,
+    QuicAckNotifier::DelegateInterface* /*ack_notifier_delegate*/) {
   ssize_t consumed_length = 0;
   for (int i = 0; i < iov_count; ++i) {
     consumed_length += iov[i].iov_len;
   }
   return QuicConsumedData(consumed_length, fin);
 }
 
 TEST_F(QuicReliableServerStreamTest, TestFraming) {
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(AnyNumber()).
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(AnyNumber()).
       WillRepeatedly(Invoke(ConsumeAllData));
 
   EXPECT_EQ(headers_string_.size(), stream_->ProcessData(
       headers_string_.c_str(), headers_string_.size()));
   EXPECT_EQ(body_.size(), stream_->ProcessData(body_.c_str(), body_.size()));
   EXPECT_EQ(11u, stream_->headers().content_length());
   EXPECT_EQ("https://www.google.com/", stream_->headers().request_uri());
   EXPECT_EQ("POST", stream_->headers().request_method());
   EXPECT_EQ(body_, stream_->body());
 }
 
 TEST_F(QuicReliableServerStreamTest, TestFramingOnePacket) {
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(AnyNumber()).
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(AnyNumber()).
       WillRepeatedly(Invoke(ConsumeAllData));
 
   string message = headers_string_ + body_;
 
   EXPECT_EQ(message.size(), stream_->ProcessData(
       message.c_str(), message.size()));
   EXPECT_EQ(11u, stream_->headers().content_length());
   EXPECT_EQ("https://www.google.com/",
             stream_->headers().request_uri());
   EXPECT_EQ("POST", stream_->headers().request_method());
   EXPECT_EQ(body_, stream_->body());
 }
 
 TEST_F(QuicReliableServerStreamTest, TestFramingExtraData) {
   string large_body = "hello world!!!!!!";
 
   // We'll automatically write out an error (headers + body)
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(2).
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(2).
       WillRepeatedly(Invoke(ConsumeAllData));
 
   EXPECT_EQ(headers_string_.size(), stream_->ProcessData(
       headers_string_.c_str(), headers_string_.size()));
   // Content length is still 11.  This will register as an error and we won't
   // accept the bytes.
   stream_->ProcessData(large_body.c_str(), large_body.size());
   stream_->TerminateFromPeer(true);
   EXPECT_EQ(11u, stream_->headers().content_length());
   EXPECT_EQ("https://www.google.com/", stream_->headers().request_uri());
   EXPECT_EQ("POST", stream_->headers().request_method());
 }
 
 TEST_F(QuicReliableServerStreamTest, TestSendResponse) {
   BalsaHeaders* request_headers =
       QuicReliableServerStreamPeer::GetMutableHeaders(stream_.get());
   request_headers->SetRequestFirstlineFromStringPieces(
       "GET",
       "https://www.google.com/foo",
       "HTTP/1.1");
 
   response_headers_.SetResponseFirstlineFromStringPieces(
       "HTTP/1.1", "200", "OK");
   response_headers_.ReplaceOrAppendHeader("content-length", "3");
 
   InSequence s;
-  EXPECT_CALL(session_, WritevData(_, _, 1, _, _)).Times(1)
+  EXPECT_CALL(session_, WritevData(_, _, 1, _, _, _)).Times(1)
       .WillOnce(WithArgs<1>(Invoke(
           this, &QuicReliableServerStreamTest::ValidateHeaders)));
 
-  EXPECT_CALL(session_, WritevData(_, _, 1, _, _)).Times(1).
+  EXPECT_CALL(session_, WritevData(_, _, 1, _, _, _)).Times(1).
       WillOnce(Return(QuicConsumedData(3, true)));
 
   stream_->SendResponse();
   EXPECT_TRUE(stream_->read_side_closed());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 TEST_F(QuicReliableServerStreamTest, TestSendErrorResponse) {
   response_headers_.SetResponseFirstlineFromStringPieces(
       "HTTP/1.1", "500", "Server Error");
   response_headers_.ReplaceOrAppendHeader("content-length", "3");
 
   InSequence s;
-  EXPECT_CALL(session_, WritevData(_, _, 1, _, _)).Times(1)
+  EXPECT_CALL(session_, WritevData(_, _, 1, _, _, _)).Times(1)
       .WillOnce(WithArgs<1>(Invoke(
           this, &QuicReliableServerStreamTest::ValidateHeaders)));
 
-  EXPECT_CALL(session_, WritevData(_, _, 1, _, _)).Times(1).
+  EXPECT_CALL(session_, WritevData(_, _, 1, _, _, _)).Times(1).
       WillOnce(Return(QuicConsumedData(3, true)));
 
   stream_->SendErrorResponse();
   EXPECT_TRUE(stream_->read_side_closed());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net