Update from https://crrev.com/316786

net/quic/quic_packet_generator.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.
 //
 // Responsible for generating packets on behalf of a QuicConnection.
 // Packets are serialized just-in-time.  Control frames are queued.
 // Ack and Feedback frames will be requested from the Connection
 // just-in-time.  When a packet needs to be sent, the Generator
 // will serialize a packet and pass it to QuicConnection::SendOrQueuePacket()
 //
@@ skipping 57 matching lines @@
 }  // namespace test
 
 class NET_EXPORT_PRIVATE QuicPacketGenerator {
  public:
   class NET_EXPORT_PRIVATE DelegateInterface {
    public:
     virtual ~DelegateInterface() {}
     virtual bool ShouldGeneratePacket(TransmissionType transmission_type,
                                       HasRetransmittableData retransmittable,
                                       IsHandshake handshake) = 0;
-    virtual QuicAckFrame* CreateAckFrame() = 0;
-    virtual QuicStopWaitingFrame* CreateStopWaitingFrame() = 0;
+    virtual void PopulateAckFrame(QuicAckFrame* ack) = 0;
+    virtual void PopulateStopWaitingFrame(
+        QuicStopWaitingFrame* stop_waiting) = 0;
     // Takes ownership of |packet.packet| and |packet.retransmittable_frames|.
     virtual void OnSerializedPacket(const SerializedPacket& packet) = 0;
     virtual void CloseConnection(QuicErrorCode error, bool from_peer) = 0;
   };
 
   // Interface which gets callbacks from the QuicPacketGenerator at interesting
   // points.  Implementations must not mutate the state of the generator
   // as a result of these callbacks.
   class NET_EXPORT_PRIVATE DebugDelegate {
    public:
@@ skipping 61 matching lines @@
   // SerializedPacket.
   QuicEncryptedPacket* SerializeVersionNegotiationPacket(
       const QuicVersionVector& supported_versions);
 
 
   // Re-serializes frames with the original packet's sequence number length.
   // Used for retransmitting packets to ensure they aren't too long.
   // Caller must ensure that any open FEC group is closed before calling this
   // method.
   SerializedPacket ReserializeAllFrames(
-      const QuicFrames& frames,
+      const RetransmittableFrames& frames,
       QuicSequenceNumberLength original_length);
 
   // Update the sequence number length to use in future packets as soon as it
   // can be safely changed.
   void UpdateSequenceNumberLength(
       QuicPacketSequenceNumber least_packet_awaited_by_peer,
       QuicPacketCount max_packets_in_flight);
 
   // Set the minimum number of bytes for the connection id length;
   void SetConnectionIdLength(uint32 length);
@@ skipping 75 matching lines @@
   // if this variable is false.
   bool should_fec_protect_;
 
   // Flags to indicate the need for just-in-time construction of a frame.
   bool should_send_ack_;
   bool should_send_stop_waiting_;
   // If we put a non-retransmittable frame (ack frame) in this packet, then we
   // have to hold a reference to it until we flush (and serialize it).
   // Retransmittable frames are referenced elsewhere so that they
   // can later be (optionally) retransmitted.
-  scoped_ptr<QuicAckFrame> pending_ack_frame_;
-  scoped_ptr<QuicStopWaitingFrame> pending_stop_waiting_frame_;
+  QuicAckFrame pending_ack_frame_;
+  QuicStopWaitingFrame pending_stop_waiting_frame_;
+  // True if an ack or stop waiting frame is already queued, and should not be
+  // re-added.
+  bool ack_queued_;
+  bool stop_waiting_queued_;
 
   // Stores notifiers that should be attached to the next serialized packet.
   std::list<QuicAckNotifier*> ack_notifiers_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacketGenerator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PACKET_GENERATOR_H_