Preparation for only writing a fraction of the iov due to flow control

net/tools/quic/quic_spdy_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_spdy_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_protocol.h"
@@ skipping 76 matching lines @@
         body_("hello world") {
     BalsaHeaders request_headers;
     request_headers.SetRequestFirstlineFromStringPieces(
         "POST", "https://www.google.com/", "HTTP/1.1");
     request_headers.ReplaceOrAppendHeader("content-length", "11");
 
     headers_string_ = SpdyUtils::SerializeRequestHeaders(request_headers);
     stream_.reset(new QuicSpdyServerStreamPeer(3, &session_));
   }
 
-  QuicConsumedData ValidateHeaders(const struct iovec* iov) {
+  QuicConsumedData ValidateHeaders(const IOVector& data) {
+    const iovec* iov = data.iovec();
     StringPiece headers =
         StringPiece(static_cast<const char*>(iov[0].iov_base), iov[0].iov_len);
     headers_string_ = SpdyUtils::SerializeResponseHeaders(
         response_headers_);
     QuicSpdyDecompressor decompressor;
     TestDecompressorVisitor visitor;
 
     // First the header id, then the compressed data.
     EXPECT_EQ(1, headers[0]);
     EXPECT_EQ(0, headers[1]);
@@ skipping 53 matching lines @@
   EpollServer eps_;
   StrictMock<MockConnection>* connection_;
   StrictMock<MockSession> session_;
   scoped_ptr<QuicSpdyServerStreamPeer> stream_;
   string headers_string_;
   string body_;
 };
 
 QuicConsumedData ConsumeAllData(
     QuicStreamId id,
-    const struct iovec* iov,
-    int iov_count,
+    const IOVector& data,
     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);
+  return QuicConsumedData(data.TotalBufferSize(), fin);
 }
 
 INSTANTIATE_TEST_CASE_P(Tests, QuicSpdyServerStreamTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicSpdyServerStreamTest, 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, StreamHeaders().content_length());
   EXPECT_EQ("https://www.google.com/", StreamHeaders().request_uri());
   EXPECT_EQ("POST", StreamHeaders().request_method());
   EXPECT_EQ(body_, StreamBody());
 }
 
 TEST_P(QuicSpdyServerStreamTest, 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, StreamHeaders().content_length());
   EXPECT_EQ("https://www.google.com/", StreamHeaders().request_uri());
   EXPECT_EQ("POST", StreamHeaders().request_method());
   EXPECT_EQ(body_, StreamBody());
 }
 
 TEST_P(QuicSpdyServerStreamTest, TestFramingExtraData) {
   string large_body = "hello world!!!!!!";
 
   // We'll automatically write out an error (headers + body)
-  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()));
   // 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());
   EXPECT_EQ(11u, StreamHeaders().content_length());
   EXPECT_EQ("https://www.google.com/", StreamHeaders().request_uri());
   EXPECT_EQ("POST", StreamHeaders().request_method());
 }
 
 TEST_P(QuicSpdyServerStreamTest, TestSendResponse) {
   BalsaHeaders* request_headers = stream_->mutable_headers();
   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;
   if (GetParam() > QUIC_VERSION_12) {
     EXPECT_CALL(session_,
-                WritevData(kHeadersStreamId, _, _, 0, false, NULL));
+                WritevData(kHeadersStreamId, _, 0, false, NULL));
   } else {
-    EXPECT_CALL(session_, WritevData(_, _, 1, _, _, _)).Times(1)
+    EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(1)
         .WillOnce(WithArgs<1>(Invoke(
             this, &QuicSpdyServerStreamTest::ValidateHeaders)));
   }
 
-  EXPECT_CALL(session_, WritevData(_, _, 1, _, _, _)).Times(1).
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(1).
       WillOnce(Return(QuicConsumedData(3, true)));
 
   QuicSpdyServerStreamPeer::SendResponse(stream_.get());
   EXPECT_TRUE(stream_->read_side_closed());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 TEST_P(QuicSpdyServerStreamTest, TestSendErrorResponse) {
   response_headers_.SetResponseFirstlineFromStringPieces(
       "HTTP/1.1", "500", "Server Error");
   response_headers_.ReplaceOrAppendHeader("content-length", "3");
 
   InSequence s;
   if (GetParam() > QUIC_VERSION_12) {
-    EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, _, 0, false, NULL));
+    EXPECT_CALL(session_,
+                WritevData(kHeadersStreamId, _, 0, false, NULL));
   } else {
-    EXPECT_CALL(session_, WritevData(_, _, 1, _, _, _)).Times(1)
+    EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(1)
         .WillOnce(WithArgs<1>(Invoke(
             this, &QuicSpdyServerStreamTest::ValidateHeaders)));
   }
 
-  EXPECT_CALL(session_, WritevData(_, _, 1, _, _, _)).Times(1).
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(1).
       WillOnce(Return(QuicConsumedData(3, true)));
 
   QuicSpdyServerStreamPeer::SendErrorResponse(stream_.get());
   EXPECT_TRUE(stream_->read_side_closed());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 TEST_P(QuicSpdyServerStreamTest, InvalidHeadersWithFin) {
   char arr[] = {
     0x05, 0x00, 0x00, 0x00,  // ....
@@ skipping 24 matching lines @@
   StringPiece data(arr + start, arraysize(arr) - start);
   QuicStreamFrame frame(stream_->id(), true, 0, MakeIOVector(data));
   // Verify that we don't crash when we get a invalid headers in stream frame.
   stream_->OnStreamFrame(frame);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net