Update from https://crrev.com/316786

net/quic/quic_packet_generator.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/quic_packet_generator.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_fec_group.h"
@@ skipping 28 matching lines @@
                                          QuicFramer* framer,
                                          QuicRandom* random_generator,
                                          DelegateInterface* delegate)
     : delegate_(delegate),
       debug_delegate_(nullptr),
       packet_creator_(connection_id, framer, random_generator),
       batch_mode_(false),
       fec_timeout_(QuicTime::Delta::Zero()),
       should_fec_protect_(false),
       should_send_ack_(false),
-      should_send_stop_waiting_(false) {
+      should_send_stop_waiting_(false),
+      ack_queued_(false),
+      stop_waiting_queued_(false) {
 }
 
 QuicPacketGenerator::~QuicPacketGenerator() {
   for (QuicFrames::iterator it = queued_control_frames_.begin();
        it != queued_control_frames_.end(); ++it) {
     switch (it->type) {
       case PADDING_FRAME:
         delete it->padding_frame;
         break;
       case STREAM_FRAME:
@@ skipping 34 matching lines @@
   packet_creator_.set_max_packets_per_fec_group(
       static_cast<size_t>(kMaxPacketsInFlightMultiplierForFecGroupSize *
                           max_packets_in_flight));
 }
 
 void QuicPacketGenerator::OnRttChange(QuicTime::Delta rtt) {
   fec_timeout_ = rtt.Multiply(kRttMultiplierForFecTimeout);
 }
 
 void QuicPacketGenerator::SetShouldSendAck(bool also_send_stop_waiting) {
-  if (pending_ack_frame_ != nullptr) {
+  if (ack_queued_) {
     // Ack already queued, nothing to do.
     return;
   }
 
-  if (also_send_stop_waiting && pending_stop_waiting_frame_ != nullptr) {
+  if (also_send_stop_waiting && stop_waiting_queued_) {
     LOG(DFATAL) << "Should only ever be one pending stop waiting frame.";
     return;
   }
 
   should_send_ack_ = true;
   should_send_stop_waiting_ = also_send_stop_waiting;
   SendQueuedFrames(false);
 }
 
 void QuicPacketGenerator::SetShouldSendStopWaiting() {
@@ skipping 233 matching lines @@
   return packet_creator_.HasPendingFrames() || HasPendingFrames();
 }
 
 bool QuicPacketGenerator::HasPendingFrames() const {
   return should_send_ack_ || should_send_stop_waiting_ ||
          !queued_control_frames_.empty();
 }
 
 bool QuicPacketGenerator::AddNextPendingFrame() {
   if (should_send_ack_) {
-    pending_ack_frame_.reset(delegate_->CreateAckFrame());
+    delegate_->PopulateAckFrame(&pending_ack_frame_);
+    ack_queued_ = true;
     // If we can't this add the frame now, then we still need to do so later.
-    should_send_ack_ = !AddFrame(QuicFrame(pending_ack_frame_.get()));
+    should_send_ack_ = !AddFrame(QuicFrame(&pending_ack_frame_));
     // Return success if we have cleared out this flag (i.e., added the frame).
     // If we still need to send, then the frame is full, and we have failed.
     return !should_send_ack_;
   }
 
   if (should_send_stop_waiting_) {
-    pending_stop_waiting_frame_.reset(delegate_->CreateStopWaitingFrame());
+    delegate_->PopulateStopWaitingFrame(&pending_stop_waiting_frame_);
+    stop_waiting_queued_ = true;
     // If we can't this add the frame now, then we still need to do so later.
     should_send_stop_waiting_ =
-        !AddFrame(QuicFrame(pending_stop_waiting_frame_.get()));
+        !AddFrame(QuicFrame(&pending_stop_waiting_frame_));
     // Return success if we have cleared out this flag (i.e., added the frame).
     // If we still need to send, then the frame is full, and we have failed.
     return !should_send_stop_waiting_;
   }
 
   LOG_IF(DFATAL, queued_control_frames_.empty())
       << "AddNextPendingFrame called with no queued control frames.";
   if (!AddFrame(queued_control_frames_.back())) {
     // Packet was full.
     return false;
@@ skipping 16 matching lines @@
 
   // There may be AckNotifiers interested in this packet.
   if (FLAGS_quic_attach_ack_notifiers_to_packets) {
     serialized_packet.notifiers.swap(ack_notifiers_);
     ack_notifiers_.clear();
   }
 
   delegate_->OnSerializedPacket(serialized_packet);
   MaybeSendFecPacketAndCloseGroup(/*force=*/false);
 
-  // The packet has now been serialized, safe to delete pending frames.
-  pending_ack_frame_.reset();
-  pending_stop_waiting_frame_.reset();
+  // The packet has now been serialized, so the frames are no longer queued.
+  ack_queued_ = false;
+  stop_waiting_queued_ = false;
 }
 
 void QuicPacketGenerator::StopSendingVersion() {
   packet_creator_.StopSendingVersion();
 }
 
 QuicPacketSequenceNumber QuicPacketGenerator::sequence_number() const {
   return packet_creator_.sequence_number();
 }
 
 QuicByteCount QuicPacketGenerator::max_packet_length() const {
   return packet_creator_.max_packet_length();
 }
 
 void QuicPacketGenerator::set_max_packet_length(QuicByteCount length) {
   packet_creator_.set_max_packet_length(length);
 }
 
 QuicEncryptedPacket* QuicPacketGenerator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   return packet_creator_.SerializeVersionNegotiationPacket(supported_versions);
 }
 
 SerializedPacket QuicPacketGenerator::ReserializeAllFrames(
-    const QuicFrames& frames,
+    const RetransmittableFrames& frames,
     QuicSequenceNumberLength original_length) {
   return packet_creator_.ReserializeAllFrames(frames, original_length);
 }
 
 void QuicPacketGenerator::UpdateSequenceNumberLength(
       QuicPacketSequenceNumber least_packet_awaited_by_peer,
       QuicPacketCount max_packets_in_flight) {
   return packet_creator_.UpdateSequenceNumberLength(
       least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 void QuicPacketGenerator::SetConnectionIdLength(uint32 length) {
   if (length == 0) {
     packet_creator_.set_connection_id_length(PACKET_0BYTE_CONNECTION_ID);
   } else if (length == 1) {
     packet_creator_.set_connection_id_length(PACKET_1BYTE_CONNECTION_ID);
   } else if (length <= 4) {
     packet_creator_.set_connection_id_length(PACKET_4BYTE_CONNECTION_ID);
   } else {
     packet_creator_.set_connection_id_length(PACKET_8BYTE_CONNECTION_ID);
   }
 }
 
 
 void QuicPacketGenerator::set_encryption_level(EncryptionLevel level) {
   packet_creator_.set_encryption_level(level);
 }
 
 }  // namespace net