Update from https://crrev.com/316786

net/quic/quic_protocol.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.
 
 #ifndef NET_QUIC_QUIC_PROTOCOL_H_
 #define NET_QUIC_QUIC_PROTOCOL_H_
 
 #include <stddef.h>
 #include <limits>
 #include <list>
@@ skipping 30 matching lines @@
 typedef uint8 QuicPacketEntropyHash;
 typedef uint32 QuicHeaderId;
 // QuicTag is the type of a tag in the wire protocol.
 typedef uint32 QuicTag;
 typedef std::vector<QuicTag> QuicTagVector;
 typedef std::map<QuicTag, std::string> QuicTagValueMap;
 // TODO(rtenneti): Didn't use SpdyPriority because SpdyPriority is uint8 and
 // QuicPriority is uint32. Use SpdyPriority when we change the QUIC_VERSION.
 typedef uint32 QuicPriority;
 
-// TODO(rch): Consider Quic specific names for these constants.
 // Default and initial maximum size in bytes of a QUIC packet.
 const QuicByteCount kDefaultMaxPacketSize = 1350;
+// Default initial maximum size in bytes of a QUIC packet for servers.
+const QuicByteCount kDefaultServerMaxPacketSize = 1000;
 // The maximum packet size of any QUIC packet, based on ethernet's max size,
 // minus the IP and UDP headers. IPv6 has a 40 byte header, UPD adds an
 // additional 8 bytes.  This is a total overhead of 48 bytes.  Ethernet's
 // max packet size is 1500 bytes,  1500 - 48 = 1452.
 const QuicByteCount kMaxPacketSize = 1452;
 // Default maximum packet size used in Linux TCP implementations.
 const QuicByteCount kDefaultTCPMSS = 1460;
 
 // We match SPDY's use of 32 when secure (since we'd compete with SPDY).
 const QuicPacketCount kInitialCongestionWindowSecure = 32;
@@ skipping 442 matching lines @@
   // The peer sent too much data, violating flow control.
   QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA = 63,
   // The peer received an invalid flow control window.
   QUIC_FLOW_CONTROL_INVALID_WINDOW = 64,
   // The connection has been IP pooled into an existing connection.
   QUIC_CONNECTION_IP_POOLED = 62,
   // The connection has too many outstanding sent packets.
   QUIC_TOO_MANY_OUTSTANDING_SENT_PACKETS = 68,
   // The connection has too many outstanding received packets.
   QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS = 69,
+  // The quic connection job to load server config is cancelled.
+  QUIC_CONNECTION_CANCELLED = 70,
 
   // Crypto errors.
 
   // Hanshake failed.
   QUIC_HANDSHAKE_FAILED = 28,
   // Handshake message contained out of order tags.
   QUIC_CRYPTO_TAGS_OUT_OF_ORDER = 29,
   // Handshake message contained too many entries.
   QUIC_CRYPTO_TOO_MANY_ENTRIES = 30,
   // Handshake message contained an invalid value length.
@@ skipping 37 matching lines @@
   // A handshake message arrived, but we are still validating the
   // previous handshake message.
   QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO = 54,
   // A server config update arrived before the handshake is complete.
   QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE = 65,
   // This connection involved a version negotiation which appears to have been
   // tampered with.
   QUIC_VERSION_NEGOTIATION_MISMATCH = 55,
 
   // No error. Used as bound while iterating.
-  QUIC_LAST_ERROR = 70,
+  QUIC_LAST_ERROR = 71,
 };
 
 struct NET_EXPORT_PRIVATE QuicPacketPublicHeader {
   QuicPacketPublicHeader();
   explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other);
   ~QuicPacketPublicHeader();
 
   // Universal header. All QuicPacket headers will have a connection_id and
   // public flags.
   QuicConnectionId connection_id;
@@ skipping 327 matching lines @@
  private:
   const char* buffer_;
   size_t length_;
   bool owns_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicData);
 };
 
 class NET_EXPORT_PRIVATE QuicPacket : public QuicData {
  public:
-  static QuicPacket* NewDataPacket(
-      char* buffer,
-      size_t length,
-      bool owns_buffer,
-      QuicConnectionIdLength connection_id_length,
-      bool includes_version,
-      QuicSequenceNumberLength sequence_number_length) {
-    return new QuicPacket(buffer, length, owns_buffer, connection_id_length,
-                          includes_version, sequence_number_length, false);
-  }
-
-  static QuicPacket* NewFecPacket(
-      char* buffer,
-      size_t length,
-      bool owns_buffer,
-      QuicConnectionIdLength connection_id_length,
-      bool includes_version,
-      QuicSequenceNumberLength sequence_number_length) {
-    return new QuicPacket(buffer, length, owns_buffer, connection_id_length,
-                          includes_version, sequence_number_length, true);
-  }
+  QuicPacket(char* buffer,
+             size_t length,
+             bool owns_buffer,
+             QuicConnectionIdLength connection_id_length,
+             bool includes_version,
+             QuicSequenceNumberLength sequence_number_length);
 
   base::StringPiece FecProtectedData() const;
   base::StringPiece AssociatedData() const;
   base::StringPiece BeforePlaintext() const;
   base::StringPiece Plaintext() const;
 
-  bool is_fec_packet() const { return is_fec_packet_; }
-
   char* mutable_data() { return buffer_; }
 
  private:
-  QuicPacket(char* buffer,
-             size_t length,
-             bool owns_buffer,
-             QuicConnectionIdLength connection_id_length,
-             bool includes_version,
-             QuicSequenceNumberLength sequence_number_length,
-             bool is_fec_packet);
-
   char* buffer_;
-  const bool is_fec_packet_;
   const QuicConnectionIdLength connection_id_length_;
   const bool includes_version_;
   const QuicSequenceNumberLength sequence_number_length_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacket);
 };
 
 class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData {
  public:
   QuicEncryptedPacket(const char* buffer, size_t length);
@@ skipping 41 matching lines @@
   IsHandshake has_crypto_handshake_;
   // Data referenced by the StringPiece of a QuicStreamFrame.
   std::vector<std::string*> stream_data_;
 
   DISALLOW_COPY_AND_ASSIGN(RetransmittableFrames);
 };
 
 struct NET_EXPORT_PRIVATE SerializedPacket {
   SerializedPacket(QuicPacketSequenceNumber sequence_number,
                    QuicSequenceNumberLength sequence_number_length,
-                   QuicPacket* packet,
+                   QuicEncryptedPacket* packet,
                    QuicPacketEntropyHash entropy_hash,
                    RetransmittableFrames* retransmittable_frames);
   ~SerializedPacket();
 
   QuicPacketSequenceNumber sequence_number;
   QuicSequenceNumberLength sequence_number_length;
-  QuicPacket* packet;
+  QuicEncryptedPacket* packet;
   QuicPacketEntropyHash entropy_hash;
   RetransmittableFrames* retransmittable_frames;
+  bool is_fec_packet;
 
   // Optional notifiers which will be informed when this packet has been ACKed.
   std::list<QuicAckNotifier*> notifiers;
 };
 
 struct NET_EXPORT_PRIVATE TransmissionInfo {
   // Used by STL when assigning into a map.
   TransmissionInfo();
 
   // Constructs a Transmission with a new all_tranmissions set
@@ skipping 19 matching lines @@
   bool in_flight;
   // True if the packet can never be acked, so it can be removed.
   bool is_unackable;
   // True if the packet is an FEC packet.
   bool is_fec_packet;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_