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

net/quic/quic_connection.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_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 
 #include <algorithm>
@@ skipping 1184 matching lines @@
   stats_.min_rtt_us = min_rtt.ToMicroseconds();
 
   QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
   if (srtt.IsZero()) {
     // If SRTT has not been set, use initial RTT instead.
     srtt = QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us());
   }
   stats_.srtt_us = srtt.ToMicroseconds();
 
   stats_.estimated_bandwidth = sent_packet_manager_.BandwidthEstimate();
-  stats_.max_packet_size = packet_generator_.GetMaxPacketLength();
+  stats_.max_packet_size = packet_generator_.GetCurrentMaxPacketLength();
   stats_.max_received_packet_size = largest_received_packet_size_;
   return stats_;
 }
 
 void QuicConnection::ProcessUdpPacket(const IPEndPoint& self_address,
                                       const IPEndPoint& peer_address,
                                       const QuicEncryptedPacket& packet) {
   if (!connected_) {
     return;
   }
@@ skipping 190 matching lines @@
   time_of_last_received_packet_ = clock_->Now();
   DVLOG(1) << ENDPOINT << "time of last received packet: "
            << time_of_last_received_packet_.ToDebuggingValue();
 
   if (last_size_ > largest_received_packet_size_) {
     largest_received_packet_size_ = last_size_;
   }
 
   if (perspective_ == Perspective::IS_SERVER &&
       encryption_level_ == ENCRYPTION_NONE &&
-      last_size_ > packet_generator_.GetMaxPacketLength()) {
+      last_size_ > packet_generator_.GetCurrentMaxPacketLength()) {
     SetMaxPacketLength(last_size_);
   }
   return true;
 }
 
 void QuicConnection::WriteQueuedPackets() {
   DCHECK(!writer_->IsWriteBlocked());
 
   if (pending_version_negotiation_packet_) {
     SendVersionNegotiationPacket();
@@ skipping 134 matching lines @@
         new QuicEncryptedPacket(buffer_copy, encrypted_length, true));
     // This assures we won't try to write *forced* packets when blocked.
     // Return true to stop processing.
     if (writer_->IsWriteBlocked()) {
       visitor_->OnWriteBlocked();
       return true;
     }
   }
 
   DCHECK_LE(encrypted_length, kMaxPacketSize);
-  DCHECK_LE(encrypted_length, packet_generator_.GetMaxPacketLength());
+  DCHECK_LE(encrypted_length, packet_generator_.GetCurrentMaxPacketLength());
   DVLOG(1) << ENDPOINT << "Sending packet " << packet_number << " : "
            << (packet->is_fec_packet
                    ? "FEC "
                    : (IsRetransmittable(*packet) == HAS_RETRANSMITTABLE_DATA
                           ? "data bearing "
                           : " ack only "))
            << ", encryption level: "
            << QuicUtils::EncryptionLevelToString(packet->encryption_level)
            << ", encrypted length:" << encrypted_length;
   DVLOG(2) << ENDPOINT << "packet(" << packet_number << "): " << std::endl
@@ skipping 393 matching lines @@
   DVLOG(1) << ENDPOINT << "Going away with error "
            << QuicUtils::ErrorToString(error) << " (" << error << ")";
 
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
   packet_generator_.AddControlFrame(
       QuicFrame(new QuicGoAwayFrame(error, last_good_stream_id, reason)));
 }
 
 QuicByteCount QuicConnection::max_packet_length() const {
-  return packet_generator_.GetMaxPacketLength();
+  return packet_generator_.GetCurrentMaxPacketLength();
 }
 
 void QuicConnection::SetMaxPacketLength(QuicByteCount length) {
   return packet_generator_.SetMaxPacketLength(LimitMaxPacketSize(length));
 }
 
 bool QuicConnection::HasQueuedData() const {
   return pending_version_negotiation_packet_ || !queued_packets_.empty() ||
          packet_generator_.HasQueuedFrames();
 }
@@ skipping 351 matching lines @@
 }
 
 StringPiece QuicConnection::GetCurrentPacket() {
   if (current_packet_data_ == nullptr) {
     return StringPiece();
   }
   return StringPiece(current_packet_data_, last_size_);
 }
 
 }  // namespace net