In QUIC, send data is copied to streams rather than frames. Protected by FLAGS_quic_reloadable_flag…

net/quic/test_tools/quic_test_utils.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/test_tools/quic_test_utils.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "net/quic/core/crypto/crypto_framer.h"
@@ skipping 54 matching lines @@
     packet_size += frame_size;
   }
   return BuildUnsizedDataPacket(framer, header, frames, packet_size);
 }
 
 QuicPacket* BuildUnsizedDataPacket(QuicFramer* framer,
                                    const QuicPacketHeader& header,
                                    const QuicFrames& frames,
                                    size_t packet_size) {
   char* buffer = new char[packet_size];
-  size_t length = framer->BuildDataPacket(header, frames, buffer, packet_size);
+  size_t length =
+      framer->BuildDataPacket(header, frames, buffer, packet_size, nullptr);
   DCHECK_NE(0u, length);
   // Re-construct the data packet with data ownership.
   return new QuicPacket(buffer, length, /* owns_buffer */ true,
                         header.public_header.connection_id_length,
                         header.public_header.version_flag,
                         header.public_header.nonce != nullptr,
                         header.public_header.packet_number_length);
 }
 
 string Sha1Hash(QuicStringPiece data) {
@@ skipping 118 matching lines @@
 }
 
 bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& frame) {
   return true;
 }
 
 MockQuicConnectionVisitor::MockQuicConnectionVisitor() {}
 
 MockQuicConnectionVisitor::~MockQuicConnectionVisitor() {}
 
+void MockQuicConnectionVisitor::SaveStreamData(QuicStreamId id,
+                                               QuicIOVector iov,
+                                               size_t iov_offset,
+                                               QuicStreamOffset offset,
+                                               QuicByteCount data_length) {
+  producer_.SaveStreamData(id, iov, iov_offset, offset, data_length);
+}
+bool MockQuicConnectionVisitor::WriteStreamData(QuicStreamId id,
+                                                QuicStreamOffset offset,
+                                                QuicByteCount data_length,
+                                                QuicDataWriter* writer) {
+  return producer_.WriteStreamData(id, offset, data_length, writer);
+}
+
 MockQuicConnectionHelper::MockQuicConnectionHelper() {}
 
 MockQuicConnectionHelper::~MockQuicConnectionHelper() {}
 
 const QuicClock* MockQuicConnectionHelper::GetClock() const {
   return &clock_;
 }
 
 QuicRandom* MockQuicConnectionHelper::GetRandomGenerator() {
   return &random_generator_;
@@ skipping 148 matching lines @@
     QuicStream* /*stream*/,
     QuicStreamId /*id*/,
     const QuicIOVector& data,
     QuicStreamOffset /*offset*/,
     StreamSendingState state,
     const QuicReferenceCountedPointer<
         QuicAckListenerInterface>& /*ack_listener*/) {
   return QuicConsumedData(data.total_length, state != NO_FIN);
 }
 
+QuicConsumedData MockQuicSession::ConsumeAndSaveAllData(
+    QuicStream* stream,
+    QuicStreamId id,
+    const QuicIOVector& data,
+    QuicStreamOffset offset,
+    StreamSendingState state,
+    const QuicReferenceCountedPointer<QuicAckListenerInterface>& ack_listener) {
+  QuicConsumedData consumed =
+      QuicConsumedData(data.total_length, state != NO_FIN);
+  if (streams_own_data() && data.total_length > 0) {
+    SaveStreamData(id, data, 0, offset, data.total_length);
+  }
+  return consumed;
+}
+
 MockQuicSpdySession::MockQuicSpdySession(QuicConnection* connection)
     : QuicSpdySession(connection, nullptr, DefaultQuicConfig()) {
   crypto_stream_.reset(new QuicCryptoStream(this));
   Initialize();
   ON_CALL(*this, WritevData(_, _, _, _, _, _))
       .WillByDefault(testing::Return(QuicConsumedData(0, false)));
 }
 
 MockQuicSpdySession::~MockQuicSpdySession() {
   delete connection();
@@ skipping 10 matching lines @@
 size_t MockQuicSpdySession::WriteHeaders(
     QuicStreamId id,
     SpdyHeaderBlock headers,
     bool fin,
     SpdyPriority priority,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   write_headers_ = std::move(headers);
   return WriteHeadersMock(id, write_headers_, fin, priority, ack_listener);
 }
 
+QuicConsumedData MockQuicSpdySession::ConsumeAndSaveAllData(
+    QuicStream* stream,
+    QuicStreamId id,
+    const QuicIOVector& data,
+    QuicStreamOffset offset,
+    StreamSendingState state,
+    const QuicReferenceCountedPointer<QuicAckListenerInterface>& ack_listener) {
+  QuicConsumedData consumed =
+      QuicConsumedData(data.total_length, state != NO_FIN);
+  if (streams_own_data() && data.total_length > 0) {
+    SaveStreamData(id, data, 0, offset, data.total_length);
+  }
+  return consumed;
+}
+
 TestQuicSpdyServerSession::TestQuicSpdyServerSession(
     QuicConnection* connection,
     const QuicConfig& config,
     const QuicCryptoServerConfig* crypto_config,
     QuicCompressedCertsCache* compressed_certs_cache)
     : QuicServerSessionBase(config,
                             connection,
                             &visitor_,
                             &helper_,
                             crypto_config,
@@ skipping 364 matching lines @@
 
 MockReceivedPacketManager::MockReceivedPacketManager(QuicConnectionStats* stats)
     : QuicReceivedPacketManager(stats) {}
 
 MockReceivedPacketManager::~MockReceivedPacketManager() {}
 
 MockConnectionCloseDelegate::MockConnectionCloseDelegate() {}
 
 MockConnectionCloseDelegate::~MockConnectionCloseDelegate() {}
 
+MockPacketCreatorDelegate::MockPacketCreatorDelegate() {}
+MockPacketCreatorDelegate::~MockPacketCreatorDelegate() {}
+
+void MockPacketCreatorDelegate::SaveStreamData(QuicStreamId id,
+                                               QuicIOVector iov,
+                                               size_t iov_offset,
+                                               QuicStreamOffset offset,
+                                               QuicByteCount data_length) {
+  producer_.SaveStreamData(id, iov, iov_offset, offset, data_length);
+}
+
+bool MockPacketCreatorDelegate::WriteStreamData(QuicStreamId id,
+                                                QuicStreamOffset offset,
+                                                QuicByteCount data_length,
+                                                QuicDataWriter* writer) {
+  return producer_.WriteStreamData(id, offset, data_length, writer);
+}
+
 void CreateClientSessionForTest(QuicServerId server_id,
                                 bool supports_stateless_rejects,
                                 QuicTime::Delta connection_start_time,
                                 QuicVersionVector supported_versions,
                                 MockQuicConnectionHelper* helper,
                                 MockAlarmFactory* alarm_factory,
                                 QuicCryptoClientConfig* crypto_client_config,
                                 PacketSavingConnection** client_connection,
                                 TestQuicSpdyClientSession** client_session) {
   CHECK(crypto_client_config);
@@ skipping 50 matching lines @@
 QuicStreamId GetNthClientInitiatedStreamId(QuicVersion version, int n) {
   return 5 + NextStreamId(version) * n;
 }
 
 QuicStreamId GetNthServerInitiatedStreamId(QuicVersion version, int n) {
   return 2 + NextStreamId(version) * n;
 }
 
 }  // namespace test
 }  // namespace net