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

net/quic/core/quic_packet_creator.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.
 //
 // Accumulates frames for the next packet until more frames no longer fit or
 // it's time to create a packet from them.
 
 #ifndef NET_QUIC_CORE_QUIC_PACKET_CREATOR_H_
 #define NET_QUIC_CORE_QUIC_PACKET_CREATOR_H_
 
 #include <cstddef>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "net/quic/core/quic_connection_close_delegate_interface.h"
 #include "net/quic/core/quic_framer.h"
 #include "net/quic/core/quic_iovector.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_pending_retransmission.h"
+#include "net/quic/core/quic_stream_frame_data_producer.h"
 #include "net/quic/platform/api/quic_export.h"
 
 namespace net {
 namespace test {
 class QuicPacketCreatorPeer;
 }
 
 class QUIC_EXPORT_PRIVATE QuicPacketCreator {
  public:
   // A delegate interface for further processing serialized packet.
   class QUIC_EXPORT_PRIVATE DelegateInterface
-      : public QuicConnectionCloseDelegateInterface {
+      : public QuicConnectionCloseDelegateInterface,
+        public QuicStreamFrameDataProducer {
    public:
     ~DelegateInterface() override {}
     // Called when a packet is serialized. Delegate does not take the ownership
     // of |serialized_packet|, but takes ownership of any frames it removes
     // from |packet.retransmittable_frames|.
     virtual void OnSerializedPacket(SerializedPacket* serialized_packet) = 0;
   };
 
   // Interface which gets callbacks from the QuicPacketCreator at interesting
   // points.  Implementations must not mutate the state of the creator
@@ skipping 163 matching lines @@
   void set_debug_delegate(DebugDelegate* debug_delegate) {
     debug_delegate_ = debug_delegate;
   }
 
   bool latched_flag_no_stop_waiting_frames() const {
     return latched_flag_no_stop_waiting_frames_;
   }
 
   QuicByteCount pending_padding_bytes() const { return pending_padding_bytes_; }
 
+  void set_delegate_saves_data(bool delegate_saves_data) {
+    delegate_saves_data_ = delegate_saves_data;
+  }
+
  private:
   friend class test::QuicPacketCreatorPeer;
 
   static bool ShouldRetransmit(const QuicFrame& frame);
 
   // Converts a raw payload to a frame which fits into the current open
   // packet.  The payload begins at |iov_offset| into the |iov|.
   // If data is empty and fin is true, the expected behavior is to consume the
   // fin but return 0.  If any data is consumed, it will be copied into a
   // new buffer that |frame| will point to and own.
@@ skipping 25 matching lines @@
   // OnSerializedPacket and reset state.
   void OnSerializedPacket();
 
   // Clears all fields of packet_ that should be cleared between serializations.
   void ClearPacket();
 
   // Returns true if a diversification nonce should be included in the current
   // packet's public header.
   bool IncludeNonceInPublicHeader();
 
+  // Returns true if |frame| starts with CHLO.
+  bool StreamFrameStartsWithChlo(QuicIOVector iov,
+                                 size_t iov_offset,
+                                 const QuicStreamFrame& frame) const;
+
   // Does not own these delegates or the framer.
   DelegateInterface* delegate_;
   DebugDelegate* debug_delegate_;
   QuicFramer* framer_;
 
   QuicBufferAllocator* const buffer_allocator_;
 
   // Controls whether version should be included while serializing the packet.
   bool send_version_in_packet_;
   // Staging variable to hold next packet number length. When sequence
@@ skipping 29 matching lines @@
   // Pending padding bytes to send. Pending padding bytes will be sent in next
   // packet(s) (after all other frames) if current constructed packet does not
   // have room to send all of them.
   QuicByteCount pending_padding_bytes_;
 
   // Indicates whether current constructed packet needs full padding to max
   // packet size. Please note, full padding does not consume pending padding
   // bytes.
   bool needs_full_padding_;
 
+  // Indicates whether frame data is saved by delegate_. TODO(fayang): Remove
+  // this boolean when deprecating quic_reloadable_flag_quic_stream_owns_data.
+  bool delegate_saves_data_;
+
   DISALLOW_COPY_AND_ASSIGN(QuicPacketCreator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_PACKET_CREATOR_H_