diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 6a2bd97..640219a 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <cstring>
+#include <limits>
 #include <string>
 #include <utility>
 
@@ -163,6 +164,11 @@
 }
 
 void QuicFixedUint32::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
+  if (tag_ == 0) {
+    QUIC_BUG
+        << "This parameter does not support writing to CryptoHandshakeMessage";
+    return;
+  }
   if (has_send_value_) {
     out->SetValue(tag_, send_value_);
   }
@@ -173,6 +179,12 @@
     HelloType /*hello_type*/,
     std::string* error_details) {
   DCHECK(error_details != nullptr);
+  if (tag_ == 0) {
+    *error_details =
+        "This parameter does not support reading from CryptoHandshakeMessage";
+    QUIC_BUG << *error_details;
+    return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
+  }
   QuicErrorCode error = peer_hello.GetUint32(tag_, &receive_value_);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
@@ -191,6 +203,92 @@
   return error;
 }
 
+QuicFixedUint62::QuicFixedUint62(QuicTag name, QuicConfigPresence presence)
+    : QuicConfigValue(name, presence),
+      has_send_value_(false),
+      has_receive_value_(false) {}
+
+QuicFixedUint62::~QuicFixedUint62() {}
+
+bool QuicFixedUint62::HasSendValue() const {
+  return has_send_value_;
+}
+
+uint64_t QuicFixedUint62::GetSendValue() const {
+  if (!has_send_value_) {
+    QUIC_BUG << "No send value to get for tag:" << QuicTagToString(tag_);
+    return 0;
+  }
+  return send_value_;
+}
+
+void QuicFixedUint62::SetSendValue(uint64_t value) {
+  if (value > kVarInt62MaxValue) {
+    QUIC_BUG << "QuicFixedUint62 invalid value " << value;
+    value = kVarInt62MaxValue;
+  }
+  has_send_value_ = true;
+  send_value_ = value;
+}
+
+bool QuicFixedUint62::HasReceivedValue() const {
+  return has_receive_value_;
+}
+
+uint64_t QuicFixedUint62::GetReceivedValue() const {
+  if (!has_receive_value_) {
+    QUIC_BUG << "No receive value to get for tag:" << QuicTagToString(tag_);
+    return 0;
+  }
+  return receive_value_;
+}
+
+void QuicFixedUint62::SetReceivedValue(uint64_t value) {
+  has_receive_value_ = true;
+  receive_value_ = value;
+}
+
+void QuicFixedUint62::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
+  if (!has_send_value_) {
+    return;
+  }
+  uint32_t send_value32;
+  if (send_value_ > std::numeric_limits<uint32_t>::max()) {
+    QUIC_BUG << "Attempting to send " << send_value_
+             << " for tag:" << QuicTagToString(tag_);
+    send_value32 = std::numeric_limits<uint32_t>::max();
+  } else {
+    send_value32 = static_cast<uint32_t>(send_value_);
+  }
+  out->SetValue(tag_, send_value32);
+}
+
+QuicErrorCode QuicFixedUint62::ProcessPeerHello(
+    const CryptoHandshakeMessage& peer_hello,
+    HelloType /*hello_type*/,
+    std::string* error_details) {
+  DCHECK(error_details != nullptr);
+  uint32_t receive_value32;
+  QuicErrorCode error = peer_hello.GetUint32(tag_, &receive_value32);
+  // GetUint32 is guaranteed to always initialize receive_value32.
+  receive_value_ = receive_value32;
+  switch (error) {
+    case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
+      if (presence_ == PRESENCE_OPTIONAL) {
+        return QUIC_NO_ERROR;
+      }
+      *error_details = "Missing " + QuicTagToString(tag_);
+      break;
+    case QUIC_NO_ERROR:
+      has_receive_value_ = true;
+      break;
+    default:
+      *error_details = "Bad " + QuicTagToString(tag_);
+      break;
+  }
+  return error;
+}
+
 QuicFixedUint128::QuicFixedUint128(QuicTag tag, QuicConfigPresence presence)
     : QuicConfigValue(tag, presence),
       has_send_value_(false),
@@ -579,11 +677,11 @@
   return ack_delay_exponent_.GetReceivedValue();
 }
 
-void QuicConfig::SetMaxPacketSizeToSend(uint32_t max_packet_size) {
+void QuicConfig::SetMaxPacketSizeToSend(uint64_t max_packet_size) {
   max_packet_size_.SetSendValue(max_packet_size);
 }
 
-uint32_t QuicConfig::GetMaxPacketSizeToSend() const {
+uint64_t QuicConfig::GetMaxPacketSizeToSend() const {
   return max_packet_size_.GetSendValue();
 }
 
@@ -591,16 +689,16 @@
   return max_packet_size_.HasReceivedValue();
 }
 
-uint32_t QuicConfig::ReceivedMaxPacketSize() const {
+uint64_t QuicConfig::ReceivedMaxPacketSize() const {
   return max_packet_size_.GetReceivedValue();
 }
 
 void QuicConfig::SetMaxDatagramFrameSizeToSend(
-    uint32_t max_datagram_frame_size) {
+    uint64_t max_datagram_frame_size) {
   max_datagram_frame_size_.SetSendValue(max_datagram_frame_size);
 }
 
-uint32_t QuicConfig::GetMaxDatagramFrameSizeToSend() const {
+uint64_t QuicConfig::GetMaxDatagramFrameSizeToSend() const {
   return max_datagram_frame_size_.GetSendValue();
 }
 
@@ -608,7 +706,7 @@
   return max_datagram_frame_size_.HasReceivedValue();
 }
 
-uint32_t QuicConfig::ReceivedMaxDatagramFrameSize() const {
+uint64_t QuicConfig::ReceivedMaxDatagramFrameSize() const {
   return max_datagram_frame_size_.GetReceivedValue();
 }
 
@@ -649,7 +747,7 @@
 }
 
 void QuicConfig::SetInitialStreamFlowControlWindowToSend(
-    uint32_t window_bytes) {
+    uint64_t window_bytes) {
   if (window_bytes < kMinimumFlowControlSendWindow) {
     QUIC_BUG << "Initial stream flow control receive window (" << window_bytes
              << ") cannot be set lower than minimum ("
@@ -659,7 +757,7 @@
   initial_stream_flow_control_window_bytes_.SetSendValue(window_bytes);
 }
 
-uint32_t QuicConfig::GetInitialStreamFlowControlWindowToSend() const {
+uint64_t QuicConfig::GetInitialStreamFlowControlWindowToSend() const {
   return initial_stream_flow_control_window_bytes_.GetSendValue();
 }
 
@@ -667,17 +765,17 @@
   return initial_stream_flow_control_window_bytes_.HasReceivedValue();
 }
 
-uint32_t QuicConfig::ReceivedInitialStreamFlowControlWindowBytes() const {
+uint64_t QuicConfig::ReceivedInitialStreamFlowControlWindowBytes() const {
   return initial_stream_flow_control_window_bytes_.GetReceivedValue();
 }
 
 void QuicConfig::SetInitialMaxStreamDataBytesIncomingBidirectionalToSend(
-    uint32_t window_bytes) {
+    uint64_t window_bytes) {
   initial_max_stream_data_bytes_incoming_bidirectional_.SetSendValue(
       window_bytes);
 }
 
-uint32_t QuicConfig::GetInitialMaxStreamDataBytesIncomingBidirectionalToSend()
+uint64_t QuicConfig::GetInitialMaxStreamDataBytesIncomingBidirectionalToSend()
     const {
   if (initial_max_stream_data_bytes_incoming_bidirectional_.HasSendValue()) {
     return initial_max_stream_data_bytes_incoming_bidirectional_.GetSendValue();
@@ -691,19 +789,19 @@
       .HasReceivedValue();
 }
 
-uint32_t QuicConfig::ReceivedInitialMaxStreamDataBytesIncomingBidirectional()
+uint64_t QuicConfig::ReceivedInitialMaxStreamDataBytesIncomingBidirectional()
     const {
   return initial_max_stream_data_bytes_incoming_bidirectional_
       .GetReceivedValue();
 }
 
 void QuicConfig::SetInitialMaxStreamDataBytesOutgoingBidirectionalToSend(
-    uint32_t window_bytes) {
+    uint64_t window_bytes) {
   initial_max_stream_data_bytes_outgoing_bidirectional_.SetSendValue(
       window_bytes);
 }
 
-uint32_t QuicConfig::GetInitialMaxStreamDataBytesOutgoingBidirectionalToSend()
+uint64_t QuicConfig::GetInitialMaxStreamDataBytesOutgoingBidirectionalToSend()
     const {
   if (initial_max_stream_data_bytes_outgoing_bidirectional_.HasSendValue()) {
     return initial_max_stream_data_bytes_outgoing_bidirectional_.GetSendValue();
@@ -717,18 +815,18 @@
       .HasReceivedValue();
 }
 
-uint32_t QuicConfig::ReceivedInitialMaxStreamDataBytesOutgoingBidirectional()
+uint64_t QuicConfig::ReceivedInitialMaxStreamDataBytesOutgoingBidirectional()
     const {
   return initial_max_stream_data_bytes_outgoing_bidirectional_
       .GetReceivedValue();
 }
 
 void QuicConfig::SetInitialMaxStreamDataBytesUnidirectionalToSend(
-    uint32_t window_bytes) {
+    uint64_t window_bytes) {
   initial_max_stream_data_bytes_unidirectional_.SetSendValue(window_bytes);
 }
 
-uint32_t QuicConfig::GetInitialMaxStreamDataBytesUnidirectionalToSend() const {
+uint64_t QuicConfig::GetInitialMaxStreamDataBytesUnidirectionalToSend() const {
   if (initial_max_stream_data_bytes_unidirectional_.HasSendValue()) {
     return initial_max_stream_data_bytes_unidirectional_.GetSendValue();
   }
@@ -739,12 +837,12 @@
   return initial_max_stream_data_bytes_unidirectional_.HasReceivedValue();
 }
 
-uint32_t QuicConfig::ReceivedInitialMaxStreamDataBytesUnidirectional() const {
+uint64_t QuicConfig::ReceivedInitialMaxStreamDataBytesUnidirectional() const {
   return initial_max_stream_data_bytes_unidirectional_.GetReceivedValue();
 }
 
 void QuicConfig::SetInitialSessionFlowControlWindowToSend(
-    uint32_t window_bytes) {
+    uint64_t window_bytes) {
   if (window_bytes < kMinimumFlowControlSendWindow) {
     QUIC_BUG << "Initial session flow control receive window (" << window_bytes
              << ") cannot be set lower than default ("
@@ -754,7 +852,7 @@
   initial_session_flow_control_window_bytes_.SetSendValue(window_bytes);
 }
 
-uint32_t QuicConfig::GetInitialSessionFlowControlWindowToSend() const {
+uint64_t QuicConfig::GetInitialSessionFlowControlWindowToSend() const {
   return initial_session_flow_control_window_bytes_.GetSendValue();
 }
 
@@ -762,7 +860,7 @@
   return initial_session_flow_control_window_bytes_.HasReceivedValue();
 }
 
-uint32_t QuicConfig::ReceivedInitialSessionFlowControlWindowBytes() const {
+uint64_t QuicConfig::ReceivedInitialSessionFlowControlWindowBytes() const {
   return initial_session_flow_control_window_bytes_.GetReceivedValue();
 }
 
@@ -1055,8 +1153,10 @@
   }
 
   initial_session_flow_control_window_bytes_.SetReceivedValue(
-      std::min<uint64_t>(params.initial_max_data.value(),
-                         std::numeric_limits<uint32_t>::max()));
+      params.initial_max_data.value());
+
+  // IETF QUIC specifies stream IDs and stream counts as 62-bit integers but
+  // our implementation uses uint32_t to represent them to save memory.
   max_bidirectional_streams_.SetReceivedValue(
       std::min<uint64_t>(params.initial_max_streams_bidi.value(),
                          std::numeric_limits<uint32_t>::max()));
@@ -1071,19 +1171,15 @@
   // received transport parameters, so a local stream is one initiated by our
   // peer, which means an incoming stream.
   initial_max_stream_data_bytes_incoming_bidirectional_.SetReceivedValue(
-      std::min<uint64_t>(params.initial_max_stream_data_bidi_local.value(),
-                         std::numeric_limits<uint32_t>::max()));
+      params.initial_max_stream_data_bidi_local.value());
   initial_max_stream_data_bytes_outgoing_bidirectional_.SetReceivedValue(
-      std::min<uint64_t>(params.initial_max_stream_data_bidi_remote.value(),
-                         std::numeric_limits<uint32_t>::max()));
+      params.initial_max_stream_data_bidi_remote.value());
   initial_max_stream_data_bytes_unidirectional_.SetReceivedValue(
-      std::min<uint64_t>(params.initial_max_stream_data_uni.value(),
-                         std::numeric_limits<uint32_t>::max()));
+      params.initial_max_stream_data_uni.value());
 
   if (GetQuicReloadableFlag(quic_negotiate_ack_delay_time)) {
     QUIC_RELOADABLE_FLAG_COUNT_N(quic_negotiate_ack_delay_time, 4, 4);
-    max_ack_delay_ms_.SetReceivedValue(std::min<uint32_t>(
-        params.max_ack_delay.value(), std::numeric_limits<uint32_t>::max()));
+    max_ack_delay_ms_.SetReceivedValue(params.max_ack_delay.value());
   }
   if (params.ack_delay_exponent.IsValid()) {
     ack_delay_exponent_.SetReceivedValue(params.ack_delay_exponent.value());
diff --git a/quic/core/quic_config.h b/quic/core/quic_config.h
index 57e89be..eca7a80 100644
--- a/quic/core/quic_config.h
+++ b/quic/core/quic_config.h
@@ -156,6 +156,43 @@
   bool has_receive_value_;
 };
 
+// Stores 62bit numbers from handshake messages that unilaterally shared by each
+// endpoint. IMPORTANT: these are serialized as 32-bit unsigned integers when
+// using QUIC_CRYPTO versions and CryptoHandshakeMessage.
+class QUIC_EXPORT_PRIVATE QuicFixedUint62 : public QuicConfigValue {
+ public:
+  QuicFixedUint62(QuicTag name, QuicConfigPresence presence);
+  ~QuicFixedUint62() override;
+
+  bool HasSendValue() const;
+
+  uint64_t GetSendValue() const;
+
+  void SetSendValue(uint64_t value);
+
+  bool HasReceivedValue() const;
+
+  uint64_t GetReceivedValue() const;
+
+  void SetReceivedValue(uint64_t value);
+
+  // If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
+  // IMPORTANT: this method serializes |send_value_| as an unsigned 32bit
+  // integer.
+  void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
+
+  // Sets |value_| to the corresponding value from |peer_hello_| if it exists.
+  QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
+                                 HelloType hello_type,
+                                 std::string* error_details) override;
+
+ private:
+  uint64_t send_value_;
+  bool has_send_value_;
+  uint64_t receive_value_;
+  bool has_receive_value_;
+};
+
 // Stores uint128 from CHLO or SHLO messages that are not negotiated.
 class QUIC_EXPORT_PRIVATE QuicFixedUint128 : public QuicConfigValue {
  public:
@@ -373,48 +410,48 @@
   uint32_t GetInitialRoundTripTimeUsToSend() const;
 
   // Sets an initial stream flow control window size to transmit to the peer.
-  void SetInitialStreamFlowControlWindowToSend(uint32_t window_bytes);
-  uint32_t GetInitialStreamFlowControlWindowToSend() const;
+  void SetInitialStreamFlowControlWindowToSend(uint64_t window_bytes);
+  uint64_t GetInitialStreamFlowControlWindowToSend() const;
   bool HasReceivedInitialStreamFlowControlWindowBytes() const;
-  uint32_t ReceivedInitialStreamFlowControlWindowBytes() const;
+  uint64_t ReceivedInitialStreamFlowControlWindowBytes() const;
 
   // Specifies the initial flow control window (max stream data) for
   // incoming bidirectional streams. Incoming means streams initiated by our
   // peer. If not set, GetInitialMaxStreamDataBytesIncomingBidirectionalToSend
   // returns the value passed to SetInitialStreamFlowControlWindowToSend.
   void SetInitialMaxStreamDataBytesIncomingBidirectionalToSend(
-      uint32_t window_bytes);
-  uint32_t GetInitialMaxStreamDataBytesIncomingBidirectionalToSend() const;
+      uint64_t window_bytes);
+  uint64_t GetInitialMaxStreamDataBytesIncomingBidirectionalToSend() const;
   bool HasReceivedInitialMaxStreamDataBytesIncomingBidirectional() const;
-  uint32_t ReceivedInitialMaxStreamDataBytesIncomingBidirectional() const;
+  uint64_t ReceivedInitialMaxStreamDataBytesIncomingBidirectional() const;
 
   // Specifies the initial flow control window (max stream data) for
   // outgoing bidirectional streams. Outgoing means streams initiated by us.
   // If not set, GetInitialMaxStreamDataBytesOutgoingBidirectionalToSend
   // returns the value passed to SetInitialStreamFlowControlWindowToSend.
   void SetInitialMaxStreamDataBytesOutgoingBidirectionalToSend(
-      uint32_t window_bytes);
-  uint32_t GetInitialMaxStreamDataBytesOutgoingBidirectionalToSend() const;
+      uint64_t window_bytes);
+  uint64_t GetInitialMaxStreamDataBytesOutgoingBidirectionalToSend() const;
   bool HasReceivedInitialMaxStreamDataBytesOutgoingBidirectional() const;
-  uint32_t ReceivedInitialMaxStreamDataBytesOutgoingBidirectional() const;
+  uint64_t ReceivedInitialMaxStreamDataBytesOutgoingBidirectional() const;
 
   // Specifies the initial flow control window (max stream data) for
   // unidirectional streams. If not set,
   // GetInitialMaxStreamDataBytesUnidirectionalToSend returns the value passed
   // to SetInitialStreamFlowControlWindowToSend.
-  void SetInitialMaxStreamDataBytesUnidirectionalToSend(uint32_t window_bytes);
-  uint32_t GetInitialMaxStreamDataBytesUnidirectionalToSend() const;
+  void SetInitialMaxStreamDataBytesUnidirectionalToSend(uint64_t window_bytes);
+  uint64_t GetInitialMaxStreamDataBytesUnidirectionalToSend() const;
   bool HasReceivedInitialMaxStreamDataBytesUnidirectional() const;
-  uint32_t ReceivedInitialMaxStreamDataBytesUnidirectional() const;
+  uint64_t ReceivedInitialMaxStreamDataBytesUnidirectional() const;
 
   // Sets an initial session flow control window size to transmit to the peer.
-  void SetInitialSessionFlowControlWindowToSend(uint32_t window_bytes);
+  void SetInitialSessionFlowControlWindowToSend(uint64_t window_bytes);
 
-  uint32_t GetInitialSessionFlowControlWindowToSend() const;
+  uint64_t GetInitialSessionFlowControlWindowToSend() const;
 
   bool HasReceivedInitialSessionFlowControlWindowBytes() const;
 
-  uint32_t ReceivedInitialSessionFlowControlWindowBytes() const;
+  uint64_t ReceivedInitialSessionFlowControlWindowBytes() const;
 
   void SetDisableConnectionMigration();
 
@@ -453,16 +490,16 @@
   uint32_t ReceivedAckDelayExponent() const;
 
   // IETF QUIC max_packet_size transport parameter.
-  void SetMaxPacketSizeToSend(uint32_t max_packet_size);
-  uint32_t GetMaxPacketSizeToSend() const;
+  void SetMaxPacketSizeToSend(uint64_t max_packet_size);
+  uint64_t GetMaxPacketSizeToSend() const;
   bool HasReceivedMaxPacketSize() const;
-  uint32_t ReceivedMaxPacketSize() const;
+  uint64_t ReceivedMaxPacketSize() const;
 
   // IETF QUIC max_datagram_frame_size transport parameter.
-  void SetMaxDatagramFrameSizeToSend(uint32_t max_datagram_frame_size);
-  uint32_t GetMaxDatagramFrameSizeToSend() const;
+  void SetMaxDatagramFrameSizeToSend(uint64_t max_datagram_frame_size);
+  uint64_t GetMaxDatagramFrameSizeToSend() const;
   bool HasReceivedMaxDatagramFrameSize() const;
-  uint32_t ReceivedMaxDatagramFrameSize() const;
+  uint64_t ReceivedMaxDatagramFrameSize() const;
 
   bool negotiated() const;
 
@@ -522,6 +559,7 @@
   // Connection options which only affect the client side.
   QuicFixedTagVector client_connection_options_;
   // Idle network timeout in seconds.
+  // Uses the max_idle_timeout transport parameter in IETF QUIC.
   QuicNegotiableUint32 idle_network_timeout_seconds_;
   // Whether to use silent close.  Defaults to 0 (false) and is otherwise true.
   QuicNegotiableUint32 silent_close_;
@@ -532,6 +570,7 @@
   // advertising.
   // The ReceivedValue is the limit on locally-created streams that
   // the peer advertised.
+  // Uses the initial_max_streams_bidi transport parameter in IETF QUIC.
   QuicFixedUint32 max_bidirectional_streams_;
   // Maximum number of unidirectional streams that the connection can
   // support.
@@ -539,27 +578,36 @@
   // advertising.
   // The ReceivedValue is the limit on locally-created streams that the peer
   // advertised.
+  // Uses the initial_max_streams_uni transport parameter in IETF QUIC.
   QuicFixedUint32 max_unidirectional_streams_;
-  // The number of bytes required for the connection ID.
+  // The number of bytes required for the connection ID. This is only used in
+  // the legacy header format used only by Q043 at this point.
   QuicFixedUint32 bytes_for_connection_id_;
   // Initial round trip time estimate in microseconds.
   QuicFixedUint32 initial_round_trip_time_us_;
 
   // Initial IETF QUIC stream flow control receive windows in bytes.
   // Incoming bidirectional streams.
-  QuicFixedUint32 initial_max_stream_data_bytes_incoming_bidirectional_;
+  // Uses the initial_max_stream_data_bidi_{local,remote} transport parameter
+  // in IETF QUIC, depending on whether we're sending or receiving.
+  QuicFixedUint62 initial_max_stream_data_bytes_incoming_bidirectional_;
   // Outgoing bidirectional streams.
-  QuicFixedUint32 initial_max_stream_data_bytes_outgoing_bidirectional_;
+  // Uses the initial_max_stream_data_bidi_{local,remote} transport parameter
+  // in IETF QUIC, depending on whether we're sending or receiving.
+  QuicFixedUint62 initial_max_stream_data_bytes_outgoing_bidirectional_;
   // Unidirectional streams.
-  QuicFixedUint32 initial_max_stream_data_bytes_unidirectional_;
+  // Uses the initial_max_stream_data_uni transport parameter in IETF QUIC.
+  QuicFixedUint62 initial_max_stream_data_bytes_unidirectional_;
 
   // Initial Google QUIC stream flow control receive window in bytes.
-  QuicFixedUint32 initial_stream_flow_control_window_bytes_;
+  QuicFixedUint62 initial_stream_flow_control_window_bytes_;
 
   // Initial session flow control receive window in bytes.
-  QuicFixedUint32 initial_session_flow_control_window_bytes_;
+  // Uses the initial_max_data transport parameter in IETF QUIC.
+  QuicFixedUint62 initial_session_flow_control_window_bytes_;
 
-  // Whether tell peer not to attempt connection migration.
+  // Whether active connection migration is allowed.
+  // Uses the disable_active_migration transport parameter in IETF QUIC.
   QuicFixedUint32 connection_migration_disabled_;
 
   // An alternate server address the client could connect to.
@@ -569,6 +617,7 @@
   QuicFixedUint32 support_max_header_list_size_;
 
   // Stateless reset token used in IETF public reset packet.
+  // Uses the stateless_reset_token transport parameter in IETF QUIC.
   QuicFixedUint128 stateless_reset_token_;
 
   // List of QuicTags whose presence immediately causes the session to
@@ -579,20 +628,23 @@
   // Maximum ack delay. The sent value is the value used on this node.
   // The received value is the value received from the peer and used by
   // the peer.
+  // Uses the max_ack_delay transport parameter in IETF QUIC.
   QuicFixedUint32 max_ack_delay_ms_;
 
-  // ack_delay_exponent parameter negotiated in IETF QUIC transport
-  // parameter negotiation. The sent exponent is the exponent that this
-  // node uses when serializing an ACK frame (and the peer should use when
-  // deserializing the frame); the received exponent is the value the peer uses
-  // to serialize frames and this node uses to deserialize them.
+  // The sent exponent is the exponent that this node uses when serializing an
+  // ACK frame (and the peer should use when deserializing the frame);
+  // the received exponent is the value the peer uses to serialize frames and
+  // this node uses to deserialize them.
+  // Uses the ack_delay_exponent transport parameter in IETF QUIC.
   QuicFixedUint32 ack_delay_exponent_;
 
-  // max_packet_size IETF QUIC transport parameter.
-  QuicFixedUint32 max_packet_size_;
+  // Maximum packet size in bytes.
+  // Uses the max_packet_size transport parameter in IETF QUIC.
+  QuicFixedUint62 max_packet_size_;
 
-  // max_datagram_frame_size IETF QUIC transport parameter.
-  QuicFixedUint32 max_datagram_frame_size_;
+  // Maximum DATAGRAM/MESSAGE frame size in bytes.
+  // Uses the max_datagram_frame_size transport parameter in IETF QUIC.
+  QuicFixedUint62 max_datagram_frame_size_;
 
   // Custom transport parameters that can be sent and received in the TLS
   // handshake.
diff --git a/quic/core/quic_constants.h b/quic/core/quic_constants.h
index b6b6c74..587e8e2 100644
--- a/quic/core/quic_constants.h
+++ b/quic/core/quic_constants.h
@@ -72,9 +72,9 @@
 
 // Minimum size of initial flow control window, for both stream and session.
 // This is only enforced when version.AllowsLowFlowControlLimits() is false.
-const uint32_t kMinimumFlowControlSendWindow = 16 * 1024;  // 16 KB
+const QuicByteCount kMinimumFlowControlSendWindow = 16 * 1024;  // 16 KB
 // Default size of initial flow control window, for both stream and session.
-const uint32_t kDefaultFlowControlSendWindow = 16 * 1024;  // 16 KB
+const QuicByteCount kDefaultFlowControlSendWindow = 16 * 1024;  // 16 KB
 
 // Maximum flow control receive window limits for connection and stream.
 const QuicByteCount kStreamReceiveWindowLimit = 16 * 1024 * 1024;   // 16 MB
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index f0c7e06..20704fb 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -224,7 +224,7 @@
   }
 }
 
-void QuicCryptoStream::OnStreamDataConsumed(size_t bytes_consumed) {
+void QuicCryptoStream::OnStreamDataConsumed(QuicByteCount bytes_consumed) {
   if (QuicVersionUsesCryptoFrames(session()->transport_version())) {
     QUIC_BUG << "Stream data consumed when CRYPTO frames should be in use";
   }
diff --git a/quic/core/quic_crypto_stream.h b/quic/core/quic_crypto_stream.h
index d3d1082..49d3704 100644
--- a/quic/core/quic_crypto_stream.h
+++ b/quic/core/quic_crypto_stream.h
@@ -111,7 +111,7 @@
   void NeuterStreamDataOfEncryptionLevel(EncryptionLevel level);
 
   // Override to record the encryption level of consumed data.
-  void OnStreamDataConsumed(size_t bytes_consumed) override;
+  void OnStreamDataConsumed(QuicByteCount bytes_consumed) override;
 
   // Returns whether there are any bytes pending retransmission in CRYPTO
   // frames.
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index c43d914..7355aea 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -29,15 +29,15 @@
 
 namespace {
 
-size_t DefaultFlowControlWindow(ParsedQuicVersion version) {
+QuicByteCount DefaultFlowControlWindow(ParsedQuicVersion version) {
   if (!version.AllowsLowFlowControlLimits()) {
     return kDefaultFlowControlSendWindow;
   }
   return 0;
 }
 
-size_t GetInitialStreamFlowControlWindowToSend(QuicSession* session,
-                                               QuicStreamId stream_id) {
+QuicByteCount GetInitialStreamFlowControlWindowToSend(QuicSession* session,
+                                                      QuicStreamId stream_id) {
   ParsedQuicVersion version = session->connection()->version();
   if (version.handshake_protocol != PROTOCOL_TLS1_3) {
     return session->config()->GetInitialStreamFlowControlWindowToSend();
@@ -60,8 +60,8 @@
       ->GetInitialMaxStreamDataBytesIncomingBidirectionalToSend();
 }
 
-size_t GetReceivedFlowControlWindow(QuicSession* session,
-                                    QuicStreamId stream_id) {
+QuicByteCount GetReceivedFlowControlWindow(QuicSession* session,
+                                           QuicStreamId stream_id) {
   ParsedQuicVersion version = session->connection()->version();
   if (version.handshake_protocol != PROTOCOL_TLS1_3) {
     if (session->config()->HasReceivedInitialStreamFlowControlWindowBytes()) {
@@ -189,7 +189,7 @@
   }
 
   // This count includes duplicate data received.
-  size_t frame_payload_size = frame.data_length;
+  QuicByteCount frame_payload_size = frame.data_length;
   stream_bytes_read_ += frame_payload_size;
 
   // Flow control is interested in tracking highest received offset.
@@ -257,7 +257,7 @@
   return true;
 }
 
-void PendingStream::MarkConsumed(size_t num_bytes) {
+void PendingStream::MarkConsumed(QuicByteCount num_bytes) {
   sequencer_.MarkConsumed(num_bytes);
 }
 
@@ -452,7 +452,7 @@
   }
 
   // This count includes duplicate data received.
-  size_t frame_payload_size = frame.data_length;
+  QuicByteCount frame_payload_size = frame.data_length;
   stream_bytes_read_ += frame_payload_size;
 
   // Flow control is interested in tracking highest received offset.
@@ -1042,7 +1042,7 @@
          (send_buffer_.stream_bytes_outstanding() || fin_outstanding_);
 }
 
-size_t QuicStream::ReadableBytes() const {
+QuicByteCount QuicStream::ReadableBytes() const {
   return sequencer_.ReadableBytes();
 }
 
@@ -1064,7 +1064,7 @@
   }
 
   // Size of buffered data.
-  size_t write_length = BufferedDataBytes();
+  QuicByteCount write_length = BufferedDataBytes();
 
   // A FIN with zero data payload should not be flow control blocked.
   bool fin_with_zero_data = (fin_buffered_ && write_length == 0);
@@ -1089,7 +1089,7 @@
     fin = false;
 
     // Writing more data would be a violation of flow control.
-    write_length = static_cast<size_t>(send_window);
+    write_length = send_window;
     QUIC_DVLOG(1) << "stream " << id() << " shortens write length to "
                   << write_length << " due to flow control";
   }
@@ -1168,7 +1168,7 @@
   return send_buffer_.bytes_acked();
 }
 
-void QuicStream::OnStreamDataConsumed(size_t bytes_consumed) {
+void QuicStream::OnStreamDataConsumed(QuicByteCount bytes_consumed) {
   send_buffer_.OnStreamDataConsumed(bytes_consumed);
 }
 
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index cc7ce4d..fe9d04c 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -76,7 +76,7 @@
 
   const QuicStreamSequencer* sequencer() const { return &sequencer_; }
 
-  void MarkConsumed(size_t num_bytes);
+  void MarkConsumed(QuicByteCount num_bytes);
 
   // Tells the sequencer to ignore all incoming data itself and not call
   // OnDataAvailable().
@@ -201,7 +201,7 @@
   bool IsWaitingForAcks() const;
 
   // Number of bytes available to read.
-  size_t ReadableBytes() const;
+  QuicByteCount ReadableBytes() const;
 
   QuicRstStreamErrorCode stream_error() const { return stream_error_; }
   QuicErrorCode connection_error() const { return connection_error_; }
@@ -392,7 +392,7 @@
   virtual void OnCanWriteNewData() {}
 
   // Called when |bytes_consumed| bytes has been consumed.
-  virtual void OnStreamDataConsumed(size_t bytes_consumed);
+  virtual void OnStreamDataConsumed(QuicByteCount bytes_consumed);
 
   // Called by the stream sequencer as bytes are consumed from the buffer.
   // If the receive window has dropped below the threshold, then send a
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index f2269bb..3e47835 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -49,7 +49,7 @@
 
 const char kData1[] = "FooAndBar";
 const char kData2[] = "EepAndBaz";
-const size_t kDataLen = 9;
+const QuicByteCount kDataLen = 9;
 
 class TestStream : public QuicStream {
  public:
@@ -125,7 +125,7 @@
 
   QuicConsumedData CloseStreamOnWriteError(
       QuicStreamId id,
-      size_t /*write_length*/,
+      QuicByteCount /*write_length*/,
       QuicStreamOffset /*offset*/,
       StreamSendingState /*state*/,
       TransmissionType /*type*/,
@@ -271,7 +271,7 @@
 TEST_P(QuicStreamTest, WriteAllData) {
   Initialize();
 
-  size_t length =
+  QuicByteCount length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
               connection_->transport_version(), PACKET_8BYTE_CONNECTION_ID,
               PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
@@ -360,7 +360,7 @@
   Initialize();
 
   EXPECT_FALSE(HasWriteBlockedStreams());
-  size_t length =
+  QuicByteCount length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
               connection_->transport_version(), PACKET_8BYTE_CONNECTION_ID,
               PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
@@ -1076,8 +1076,9 @@
   EXPECT_FALSE(stream_->CanWriteNewData());
 
   // Send buffered data to make buffered data size < threshold.
-  size_t data_to_write = 3 * data.length() - 200 -
-                         GetQuicFlag(FLAGS_quic_buffered_data_threshold) + 1;
+  QuicByteCount data_to_write =
+      3 * data.length() - 200 -
+      GetQuicFlag(FLAGS_quic_buffered_data_threshold) + 1;
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(InvokeWithoutArgs([this, data_to_write]() {
         return session_->ConsumeData(stream_->id(), data_to_write, 200u, NO_FIN,
@@ -1182,7 +1183,7 @@
 
   Initialize();
   char data[1024];
-  std::vector<std::pair<char*, size_t>> buffers;
+  std::vector<std::pair<char*, QuicByteCount>> buffers;
   buffers.push_back(std::make_pair(data, QUICHE_ARRAYSIZE(data)));
   buffers.push_back(std::make_pair(data, QUICHE_ARRAYSIZE(data)));
   QuicTestMemSliceVector vector1(buffers);
@@ -1210,8 +1211,9 @@
   EXPECT_EQ(2 * QUICHE_ARRAYSIZE(data) - 100, stream_->BufferedDataBytes());
   EXPECT_FALSE(stream_->fin_buffered());
 
-  size_t data_to_write = 2 * QUICHE_ARRAYSIZE(data) - 100 -
-                         GetQuicFlag(FLAGS_quic_buffered_data_threshold) + 1;
+  QuicByteCount data_to_write =
+      2 * QUICHE_ARRAYSIZE(data) - 100 -
+      GetQuicFlag(FLAGS_quic_buffered_data_threshold) + 1;
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(InvokeWithoutArgs([this, data_to_write]() {
         return session_->ConsumeData(stream_->id(), data_to_write, 100u, NO_FIN,
@@ -1245,7 +1247,7 @@
   Initialize();
   QuicStreamPeer::SetStreamBytesWritten(kMaxStreamLength - 5u, stream_);
   char data[5];
-  std::vector<std::pair<char*, size_t>> buffers;
+  std::vector<std::pair<char*, QuicByteCount>> buffers;
   buffers.push_back(std::make_pair(data, QUICHE_ARRAYSIZE(data)));
   QuicTestMemSliceVector vector1(buffers);
   QuicMemSliceSpan span1 = vector1.span();
@@ -1258,7 +1260,7 @@
   QuicConsumedData consumed = stream_->WriteMemSlices(span1, false);
   EXPECT_EQ(5u, consumed.bytes_consumed);
 
-  std::vector<std::pair<char*, size_t>> buffers2;
+  std::vector<std::pair<char*, QuicByteCount>> buffers2;
   buffers2.push_back(std::make_pair(data, 1u));
   QuicTestMemSliceVector vector2(buffers);
   QuicMemSliceSpan span2 = vector2.span();
diff --git a/quic/core/quic_types.h b/quic/core/quic_types.h
index 0d84b07..a3d43b8 100644
--- a/quic/core/quic_types.h
+++ b/quic/core/quic_types.h
@@ -23,7 +23,6 @@
 
 using QuicPacketLength = uint16_t;
 using QuicControlFrameId = uint32_t;
-using QuicHeaderId = uint32_t;
 using QuicMessageId = uint32_t;
 using QuicDatagramFlowId = uint64_t;
 
diff --git a/quic/quartc/quartc_stream.cc b/quic/quartc/quartc_stream.cc
index 9edf370..01494c5 100644
--- a/quic/quartc/quartc_stream.cc
+++ b/quic/quartc/quartc_stream.cc
@@ -56,7 +56,7 @@
   delegate_->OnClose(this);
 }
 
-void QuartcStream::OnStreamDataConsumed(size_t bytes_consumed) {
+void QuartcStream::OnStreamDataConsumed(QuicByteCount bytes_consumed) {
   QuicStream::OnStreamDataConsumed(bytes_consumed);
 
   if (delegate_) {
diff --git a/quic/quartc/quartc_stream.h b/quic/quartc/quartc_stream.h
index 40e8328..7f3c28d 100644
--- a/quic/quartc/quartc_stream.h
+++ b/quic/quartc/quartc_stream.h
@@ -34,7 +34,7 @@
 
   void OnClose() override;
 
-  void OnStreamDataConsumed(size_t bytes_consumed) override;
+  void OnStreamDataConsumed(QuicByteCount bytes_consumed) override;
 
   void OnDataBuffered(
       QuicStreamOffset offset,