relnote: Allow individual QUIC writers to limit the maximum packet size.

net/quic/quic_connection.h

 // 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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 439 matching lines @@
     debug_visitor_ = debug_visitor;
     packet_generator_.set_debug_delegate(debug_visitor);
     sent_packet_manager_.set_debug_delegate(debug_visitor);
   }
   const IPEndPoint& self_address() const { return self_address_; }
   const IPEndPoint& peer_address() const { return peer_address_; }
   QuicConnectionId connection_id() const { return connection_id_; }
   const QuicClock* clock() const { return clock_; }
   QuicRandom* random_generator() const { return random_generator_; }
   QuicByteCount max_packet_length() const;
-  void set_max_packet_length(QuicByteCount length);
+  void SetMaxPacketLength(QuicByteCount length);
 
   size_t mtu_probe_count() const { return mtu_probe_count_; }
 
   bool connected() const { return connected_; }
 
   bool goaway_sent() const { return goaway_sent_; }
 
   bool goaway_received() const { return goaway_received_; }
 
   // Must only be called on client connections.
@@ skipping 292 matching lines @@
   void MaybeSetMtuAlarm();
 
   // On arrival of a new packet, checks to see if the socket addresses have
   // changed since the last packet we saw on this connection.
   void CheckForAddressMigration(const IPEndPoint& self_address,
                                 const IPEndPoint& peer_address);
 
   HasRetransmittableData IsRetransmittable(const QueuedPacket& packet);
   bool IsConnectionClose(const QueuedPacket& packet);
 
+  // Set the size of the packet we are targeting while doing path MTU discovery.
+  void SetMtuDiscoveryTarget(QuicByteCount target);
+
+  // Validates the potential maximum packet size, and reduces it if it exceeds
+  // the largest supported by the protocol or the packet writer.
+  QuicByteCount LimitMaxPacketSize(QuicByteCount suggested_max_packet_size);
+
   QuicFramer framer_;
   QuicConnectionHelperInterface* helper_;  // Not owned.
   QuicPacketWriter* writer_;  // Owned or not depending on |owns_writer_|.
   bool owns_writer_;
   // Encryption level for new packets. Should only be changed via
   // SetDefaultEncryptionLevel().
   EncryptionLevel encryption_level_;
   bool has_forward_secure_encrypter_;
   // The packet number of the first packet which will be encrypted with the
   // foward-secure encrypter, even if the peer has not started sending
@@ skipping 192 matching lines @@
 
   // Whether a GoAway has been received.
   bool goaway_received_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_