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

net/quic/test_tools/simulator/quic_endpoint.h

 // 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.
 
 #ifndef NET_QUIC_TEST_TOOLS_SIMULATOR_QUIC_ENDPOINT_H_
 #define NET_QUIC_TEST_TOOLS_SIMULATOR_QUIC_ENDPOINT_H_
 
 #include "net/quic/core/crypto/null_decrypter.h"
 #include "net/quic/core/crypto/null_encrypter.h"
 #include "net/quic/core/quic_connection.h"
 #include "net/quic/core/quic_packets.h"
+#include "net/quic/test_tools/simple_data_producer.h"
 #include "net/quic/test_tools/simulator/link.h"
 #include "net/quic/test_tools/simulator/queue.h"
 #include "net/tools/quic/quic_default_packet_writer.h"
 
 namespace net {
 namespace simulator {
 
 // Size of the TX queue used by the kernel/NIC.  1000 is the Linux
 // kernel default.
 const QuicByteCount kTxQueueSize = 1000;
@@ skipping 61 matching lines @@
   void OnConnectionClosed(QuicErrorCode error,
                           const std::string& error_details,
                           ConnectionCloseSource source) override {}
   void OnWriteBlocked() override {}
   void OnSuccessfulVersionNegotiation(const QuicVersion& version) override {}
   void OnCongestionWindowChange(QuicTime now) override {}
   void OnConnectionMigration(PeerAddressChangeType type) override {}
   void OnPathDegrading() override {}
   void PostProcessAfterData() override {}
   void OnAckNeedsRetransmittableFrame() override {}
+  void SaveStreamData(QuicStreamId id,
+                      QuicIOVector iov,
+                      size_t iov_offset,
+                      QuicStreamOffset offset,
+                      QuicByteCount data_length) override;
+  bool WriteStreamData(QuicStreamId id,
+                       QuicStreamOffset offset,
+                       QuicByteCount data_length,
+                       QuicDataWriter* writer) override;
   // End QuicConnectionVisitorInterface implementation.
 
  private:
   // A Writer object that writes into the |nic_tx_queue_|.
   class Writer : public QuicPacketWriter {
    public:
     explicit Writer(QuicEndpoint* endpoint);
     ~Writer() override;
 
     WriteResult WritePacket(const char* buffer,
@@ skipping 30 matching lines @@
   QuicByteCount bytes_transferred_;
 
   // Counts the number of times the writer became write-blocked.
   size_t write_blocked_count_;
 
   // Set to true if the endpoint receives stream data different from what it
   // expects.
   bool wrong_data_received_;
 
   std::unique_ptr<char[]> transmission_buffer_;
+
+  test::SimpleDataProducer producer_;
 };
 
 // Multiplexes multiple connections at the same host on the network.
 class QuicEndpointMultiplexer : public Endpoint,
                                 public UnconstrainedPortInterface {
  public:
   QuicEndpointMultiplexer(std::string name,
                           std::initializer_list<QuicEndpoint*> endpoints);
   ~QuicEndpointMultiplexer() override;
 
   // Receives a packet and passes it to the specified endpoint if that endpoint
   // is one of the endpoints being multiplexed, otherwise ignores the packet.
   void AcceptPacket(std::unique_ptr<Packet> packet) override;
   UnconstrainedPortInterface* GetRxPort() override;
 
   // Sets the egress port for all the endpoints being multiplexed.
   void SetTxPort(ConstrainedPortInterface* port) override;
 
   void Act() override {}
 
  private:
   std::unordered_map<std::string, QuicEndpoint*> mapping_;
 };
 
 }  // namespace simulator
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_SIMULATOR_QUIC_ENDPOINT_H_