Remove max_packet_length from QuicPacketGenerator, because it is no longer necessary with FEC gone.…

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"
 
 using base::StringPiece;
 
 namespace net {
 
 QuicPacketGenerator::QuicPacketGenerator(QuicConnectionId connection_id,
                                          QuicFramer* framer,
                                          QuicRandom* random_generator,
                                          QuicBufferAllocator* buffer_allocator,
                                          DelegateInterface* delegate)
     : delegate_(delegate),
       packet_creator_(connection_id,
                       framer,
                       random_generator,
                       buffer_allocator,
                       delegate),
       batch_mode_(false),
       should_send_ack_(false),
-      should_send_stop_waiting_(false),
-      max_packet_length_(kDefaultMaxPacketSize) {}
+      should_send_stop_waiting_(false) {}
 
 QuicPacketGenerator::~QuicPacketGenerator() {
   QuicUtils::DeleteFrames(&queued_control_frames_);
 }
 
 void QuicPacketGenerator::SetShouldSendAck(bool also_send_stop_waiting) {
   if (packet_creator_.has_ack()) {
     // Ack already queued, nothing to do.
     return;
   }
@@ skipping 85 matching lines @@
 
 void QuicPacketGenerator::GenerateMtuDiscoveryPacket(
     QuicByteCount target_mtu,
     QuicAckListenerInterface* listener) {
   // MTU discovery frames must be sent by themselves.
   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();
+  const QuicByteCount current_mtu = GetCurrentMaxPacketLength();
 
   // 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);
   const bool success = packet_creator_.AddPaddedSavedFrame(frame);
   if (listener != nullptr) {
@@ skipping 89 matching lines @@
 }
 
 void QuicPacketGenerator::StopSendingVersion() {
   packet_creator_.StopSendingVersion();
 }
 
 QuicPacketNumber QuicPacketGenerator::packet_number() const {
   return packet_creator_.packet_number();
 }
 
-QuicByteCount QuicPacketGenerator::GetMaxPacketLength() const {
-  return max_packet_length_;
-}
-
 QuicByteCount QuicPacketGenerator::GetCurrentMaxPacketLength() const {
   return packet_creator_.max_packet_length();
 }
 
 void QuicPacketGenerator::SetMaxPacketLength(QuicByteCount length) {
-  max_packet_length_ = length;
-  if (packet_creator_.CanSetMaxPacketLength()) {
-    packet_creator_.SetMaxPacketLength(length);
-  }
+  DCHECK(packet_creator_.CanSetMaxPacketLength());
+  packet_creator_.SetMaxPacketLength(length);
 }
 
 QuicEncryptedPacket* QuicPacketGenerator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   return packet_creator_.SerializeVersionNegotiationPacket(supported_versions);
 }
 
 void QuicPacketGenerator::ReserializeAllFrames(
     const PendingRetransmission& retransmission,
     char* buffer,
@@ skipping 31 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