Replace QUIC's PathMtuAckListener with a non-AckListener approach. Protected by FLAGS_quic_no_mtu_d…

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 300 matching lines @@
       largest_received_packet_size_(0),
       goaway_sent_(false),
       goaway_received_(false),
       multipath_enabled_(false) {
   DVLOG(1) << ENDPOINT
            << "Created connection with connection_id: " << connection_id;
   framer_.set_visitor(this);
   framer_.set_received_entropy_calculator(&received_packet_manager_);
   last_stop_waiting_frame_.least_unacked = 0;
   stats_.connection_creation_time = clock_->ApproximateNow();
+  // TODO(ianswett): Supply the NetworkChangeVisitor as a constructor argument
+  // and make it required non-null, because it's always used.
   sent_packet_manager_->SetNetworkChangeVisitor(this);
   // Allow the packet writer to potentially reduce the packet size to a value
   // even smaller than kDefaultMaxPacketSize.
   SetMaxPacketLength(perspective_ == Perspective::IS_SERVER
                          ? kDefaultServerMaxPacketSize
                          : kDefaultMaxPacketSize);
   received_packet_manager_.SetVersion(version());
 }
 
 QuicConnection::~QuicConnection() {
@@ skipping 1468 matching lines @@
   }
 
   if (debug_visitor_)
     debug_visitor_->OnRttChanged(rtt);
 }
 
 void QuicConnection::OnPathDegrading() {
   visitor_->OnPathDegrading();
 }
 
+void QuicConnection::OnPathMtuIncreased(QuicPacketLength packet_size) {
+  DCHECK(FLAGS_quic_no_mtu_discovery_ack_listener);
+  if (packet_size > max_packet_length()) {
+    SetMaxPacketLength(packet_size);
+  }
+}
+
 void QuicConnection::OnHandshakeComplete() {
   sent_packet_manager_->SetHandshakeConfirmed();
   // The client should immediately ack the SHLO to confirm the handshake is
   // complete with the server.
   if (perspective_ == Perspective::IS_CLIENT && !ack_queued_ &&
       ack_frame_updated()) {
     ack_alarm_->Cancel();
     ack_alarm_->Set(clock_->ApproximateNow());
   }
 }
@@ skipping 545 matching lines @@
 
   // Create a listener for the new probe.  The ownership of the listener is
   // transferred to the AckNotifierManager.  The notifier will get destroyed
   // before the connection (because it's stored in one of the connection's
   // subfields), hence |this| pointer is guaranteed to stay valid at all times.
   scoped_refptr<MtuDiscoveryAckListener> last_mtu_discovery_ack_listener(
       new MtuDiscoveryAckListener(this, target_mtu));
 
   // Send the probe.
   packet_generator_.GenerateMtuDiscoveryPacket(
-      target_mtu, last_mtu_discovery_ack_listener.get());
+      target_mtu, FLAGS_quic_no_mtu_discovery_ack_listener
+                      ? nullptr
+                      : last_mtu_discovery_ack_listener.get());
 }
 
 void QuicConnection::DiscoverMtu() {
   DCHECK(!mtu_discovery_alarm_->IsSet());
 
-  // Chcek if the MTU has been already increased.
+  // Check if the MTU has been already increased.
   if (mtu_discovery_target_ <= max_packet_length()) {
     return;
   }
 
-  // Schedule the next probe *before* sending the current one.  This is
-  // important, otherwise, when SendMtuDiscoveryPacket() is called,
+  // Calculate the packet number of the next probe *before* sending the current
+  // one.  Otherwise, when SendMtuDiscoveryPacket() is called,
   // MaybeSetMtuAlarm() will not realize that the probe has been just sent, and
   // will reschedule this probe again.
   packets_between_mtu_probes_ *= 2;
   next_mtu_probe_at_ =
       packet_number_of_last_sent_packet_ + packets_between_mtu_probes_ + 1;
   ++mtu_probe_count_;
 
   DVLOG(2) << "Sending a path MTU discovery packet #" << mtu_probe_count_;
   SendMtuDiscoveryPacket(mtu_discovery_target_);
 
@@ skipping 93 matching lines @@
 // the sender and a signaling mechanism -- if the sender uses a
 // different MinRTO, we may get spurious retransmissions. May not have
 // any benefits, but if the delayed ack becomes a significant source
 // of (likely, tail) latency, then consider such a mechanism.
 const QuicTime::Delta QuicConnection::DelayedAckTime() {
   return QuicTime::Delta::FromMilliseconds(
       min(kMaxDelayedAckTimeMs, kMinRetransmissionTimeMs / 2));
 }
 
 }  // namespace net