Remove the force param from QuicPacketGenerator::SetMaxPacketLength because path MTU packets should…

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/logging.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
@@ skipping 110 matching lines @@
   }
 
   DCHECK(InBatchMode() || !packet_creator_.HasPendingFrames());
   return QuicConsumedData(total_bytes_consumed, fin_consumed);
 }
 
 void QuicPacketGenerator::GenerateMtuDiscoveryPacket(
     QuicByteCount target_mtu,
     QuicAckListenerInterface* listener) {
   // MTU discovery frames must be sent by themselves.
-  DCHECK(!InBatchMode() && !packet_creator_.HasPendingFrames());
+  if (!packet_creator_.CanSetMaxPacketLength()) {
+    QUIC_BUG << "MTU discovery packets should only be sent when no other "
+             << "frames needs to be sent.";
+    return;
+  }
   const QuicByteCount current_mtu = GetMaxPacketLength();
 
   // The MTU discovery frame is allocated on the stack, since it is going to be
   // serialized within this function.
   QuicMtuDiscoveryFrame mtu_discovery_frame;
   QuicFrame frame(mtu_discovery_frame);
 
   // Send the probe packet with the new length.
-  SetMaxPacketLength(target_mtu, /*force=*/true);
+  SetMaxPacketLength(target_mtu);
   const bool success = packet_creator_.AddPaddedSavedFrame(frame);
   if (listener != nullptr) {
     packet_creator_.AddAckListener(listener, 0);
   }
   packet_creator_.Flush();
   // The only reason AddFrame can fail is that the packet is too full to fit in
   // a ping.  This is not possible for any sane MTU.
   DCHECK(success);
 
   // Reset the packet length back.
-  SetMaxPacketLength(current_mtu, /*force=*/true);
+  SetMaxPacketLength(current_mtu);
 }
 
 bool QuicPacketGenerator::CanSendWithNextPendingFrameAddition() const {
   DCHECK(HasPendingFrames());
   HasRetransmittableData retransmittable =
       (should_send_ack_ || should_send_stop_waiting_)
           ? NO_RETRANSMITTABLE_DATA
           : HAS_RETRANSMITTABLE_DATA;
   if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
     DCHECK(!queued_control_frames_.empty());  // These are retransmittable.
@@ skipping 78 matching lines @@
 }
 
 QuicByteCount QuicPacketGenerator::GetMaxPacketLength() const {
   return max_packet_length_;
 }
 
 QuicByteCount QuicPacketGenerator::GetCurrentMaxPacketLength() const {
   return packet_creator_.max_packet_length();
 }
 
-void QuicPacketGenerator::SetMaxPacketLength(QuicByteCount length, bool force) {
-  // If we cannot immediately set new maximum packet length, and the |force|
-  // flag is set, we have to flush the contents of the queue.
-  if (!packet_creator_.CanSetMaxPacketLength() && force) {
-    SendQueuedFrames(/*flush=*/true);
-    DCHECK(packet_creator_.CanSetMaxPacketLength());
-  }
-
+void QuicPacketGenerator::SetMaxPacketLength(QuicByteCount length) {
   max_packet_length_ = length;
   if (packet_creator_.CanSetMaxPacketLength()) {
     packet_creator_.SetMaxPacketLength(length);
   }
 }
 
 QuicEncryptedPacket* QuicPacketGenerator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   return packet_creator_.SerializeVersionNegotiationPacket(supported_versions);
 }
@@ skipping 35 matching lines @@
 
 void QuicPacketGenerator::SetCurrentPath(
     QuicPathId path_id,
     QuicPacketNumber least_packet_awaited_by_peer,
     QuicPacketCount max_packets_in_flight) {
   packet_creator_.SetCurrentPath(path_id, least_packet_awaited_by_peer,
                                  max_packets_in_flight);
 }
 
 }  // namespace net