Update from https://crrev.com/309415

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_fec_group.h"
+#include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 
 namespace net {
 
 namespace {
 
 // We want to put some space between a protected packet and the FEC packet to
 // avoid losing them both within the same loss episode. On the other hand,
@@ skipping 66 matching lines @@
 
 void QuicPacketGenerator::OnCongestionWindowChange(
     QuicPacketCount max_packets_in_flight) {
   packet_creator_.set_max_packets_per_fec_group(
       static_cast<size_t>(kMaxPacketsInFlightMultiplierForFecGroupSize *
                           max_packets_in_flight));
 }
 
 void QuicPacketGenerator::SetShouldSendAck(bool also_send_feedback,
                                            bool also_send_stop_waiting) {
+  if (FLAGS_quic_disallow_multiple_pending_ack_frames) {
+    if (pending_ack_frame_ != nullptr) {
+      // Ack already queued, nothing to do.
+      return;
+    }
+
+    if (also_send_feedback && pending_feedback_frame_ != nullptr) {
+      LOG(DFATAL) << "Should only ever be one pending feedback frame.";
+      return;
+    }
+
+    if (also_send_stop_waiting && pending_stop_waiting_frame_ != nullptr) {
+      LOG(DFATAL) << "Should only ever be one pending stop waiting frame.";
+      return;
+    }
+  }
+
   should_send_ack_ = true;
   should_send_feedback_ = also_send_feedback;
   should_send_stop_waiting_ = also_send_stop_waiting;
   SendQueuedFrames(false);
 }
 
 void QuicPacketGenerator::SetShouldSendStopWaiting() {
   should_send_stop_waiting_ = true;
   SendQueuedFrames(false);
 }
@@ skipping 234 matching lines @@
     debug_delegate_->OnFrameAddedToPacket(frame);
   }
   return success;
 }
 
 void QuicPacketGenerator::SerializeAndSendPacket() {
   SerializedPacket serialized_packet = packet_creator_.SerializePacket();
   DCHECK(serialized_packet.packet);
   delegate_->OnSerializedPacket(serialized_packet);
   MaybeSendFecPacketAndCloseGroup(false);
+
+  // The packet has now been serialized, safe to delete pending frames.
+  if (FLAGS_quic_disallow_multiple_pending_ack_frames) {
+    pending_ack_frame_.reset();
+    pending_feedback_frame_.reset();
+    pending_stop_waiting_frame_.reset();
+  }
 }
 
 void QuicPacketGenerator::StopSendingVersion() {
   packet_creator_.StopSendingVersion();
 }
 
 QuicPacketSequenceNumber QuicPacketGenerator::sequence_number() const {
   return packet_creator_.sequence_number();
 }
 
@@ skipping 34 matching lines @@
     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