Coalesce small buffers in net::BidirectionalStream

net/quic/test_tools/quic_test_packet_maker.cc

 // Copyright 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/quic/test_tools/quic_test_packet_maker.h"
 
 #include <list>
 
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_http_utils.h"
@@ skipping 269 matching lines @@
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     QuicStreamOffset offset,
     base::StringPiece data) {
   InitializeHeader(packet_number, should_include_version);
   QuicStreamFrame frame(stream_id, fin, offset, data);
   return MakePacket(header_, QuicFrame(&frame));
 }
 
+scoped_ptr<QuicReceivedPacket>
+QuicTestPacketMaker::MakeMultipleDataFramesPacket(
+    QuicPacketNumber packet_number,
+    QuicStreamId stream_id,
+    bool should_include_version,
+    bool fin,
+    QuicStreamOffset offset,
+    const std::vector<std::string>& data_writes) {
+  InitializeHeader(packet_number, should_include_version);
+  QuicFrames data_frames =
+      MakeMultipleDataFrames(stream_id, fin, offset, data_writes);
+  return MakeMultipleFramesPacket(header_, data_frames);
+}
+
 scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckAndDataPacket(
     QuicPacketNumber packet_number,
     bool include_version,
     QuicStreamId stream_id,
     QuicPacketNumber largest_received,
     QuicPacketNumber least_unacked,
     bool fin,
     QuicStreamOffset offset,
     base::StringPiece data) {
   InitializeHeader(packet_number, include_version);
 
   QuicAckFrame ack(MakeAckFrame(largest_received));
   ack.ack_delay_time = QuicTime::Delta::Zero();
   for (QuicPacketNumber i = least_unacked; i <= largest_received; ++i) {
     ack.received_packet_times.push_back(make_pair(i, clock_->Now()));
   }
   QuicFrames frames;
   frames.push_back(QuicFrame(&ack));
 
   QuicStopWaitingFrame stop_waiting;
   stop_waiting.least_unacked = least_unacked;
   frames.push_back(QuicFrame(&stop_waiting));
 
   QuicStreamFrame stream_frame(stream_id, fin, offset, data);
   frames.push_back(QuicFrame(&stream_frame));
 
   return MakeMultipleFramesPacket(header_, frames);
 }
 
+scoped_ptr<QuicReceivedPacket>
+QuicTestPacketMaker::MakeRequestHeadersAndMultipleDataFramesPacket(
+    QuicPacketNumber packet_number,
+    QuicStreamId stream_id,
+    bool should_include_version,
+    bool fin,
+    SpdyPriority priority,
+    const SpdyHeaderBlock& headers,
+    size_t* spdy_headers_frame_length,
+    const std::vector<std::string>& data_writes) {
+  InitializeHeader(packet_number, should_include_version);
+  SpdySerializedFrame spdy_frame;
+  if (spdy_request_framer_.protocol_version() == SPDY3) {
+    SpdySynStreamIR syn_stream(stream_id);
+    syn_stream.set_header_block(headers);
+    syn_stream.set_fin(fin);
+    syn_stream.set_priority(priority);
+    spdy_frame = spdy_request_framer_.SerializeSynStream(syn_stream);
+  } else {
+    SpdyHeadersIR headers_frame(stream_id);
+    headers_frame.set_header_block(headers);
+    headers_frame.set_fin(fin);
+    headers_frame.set_priority(priority);
+    headers_frame.set_has_priority(true);
+    spdy_frame = spdy_request_framer_.SerializeFrame(headers_frame);
+  }
+  if (spdy_headers_frame_length) {
+    *spdy_headers_frame_length = spdy_frame.size();
+  }
+  QuicStreamFrame frame(
+      kHeadersStreamId, false, 0,
+      base::StringPiece(spdy_frame.data(), spdy_frame.size()));
+
+  QuicFrames frames;
+  frames.push_back(QuicFrame(&frame));
+
+  QuicFrames data_frames =
+      MakeMultipleDataFrames(stream_id, fin, 0, data_writes);
+  for (auto data_frame : data_frames) {
+    frames.push_back(data_frame);
+  }
+  return MakeMultipleFramesPacket(header_, frames);
+}
+
 scoped_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     SpdyPriority priority,
     const SpdyHeaderBlock& headers,
     size_t* spdy_headers_frame_length) {
   return MakeRequestHeadersPacket(packet_number, stream_id,
                                   should_include_version, fin, priority,
@@ skipping 175 matching lines @@
       BuildUnsizedDataPacket(&framer, header, frames));
   char buffer[kMaxPacketSize];
   size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
                                                 header.packet_number, *packet,
                                                 buffer, kMaxPacketSize);
   EXPECT_NE(0u, encrypted_size);
   QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(), false);
   return scoped_ptr<QuicReceivedPacket>(encrypted.Clone());
 }
 
+QuicFrames QuicTestPacketMaker::MakeMultipleDataFrames(
+    QuicStreamId stream_id,
+    bool fin,
+    QuicStreamOffset offset,
+    const std::vector<std::string>& data_writes) {
+  QuicFrames result_frames;
+  for (size_t i = 0; i < data_writes.size(); ++i) {
+    bool is_fin = fin && (i == data_writes.size() - 1);
+    QuicStreamFrame* stream_frame = new QuicStreamFrame(
+        stream_id, is_fin, offset, base::StringPiece(data_writes[i]));
+    offset += data_writes[i].length();
+    DVLOG(1) << "Adding frame: " << QuicFrame(stream_frame);
+    result_frames.push_back(QuicFrame(stream_frame));
+  }
+  return result_frames;
+}
+
 void QuicTestPacketMaker::InitializeHeader(QuicPacketNumber packet_number,
                                            bool should_include_version) {
   header_.public_header.connection_id = connection_id_;
   header_.public_header.reset_flag = false;
   header_.public_header.version_flag = should_include_version;
   header_.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header_.packet_number = packet_number;
   header_.fec_group = 0;
   header_.entropy_flag = false;
   header_.fec_flag = false;
 }
 
 }  // namespace test
 }  // namespace net