diff --git a/quiche/quic/core/quic_constants.h b/quiche/quic/core/quic_constants.h
index 6f89ec1..46af2e8 100644
--- a/quiche/quic/core/quic_constants.h
+++ b/quiche/quic/core/quic_constants.h
@@ -18,106 +18,114 @@
 namespace quic {
 
 // Simple time constants.
-const uint64_t kNumSecondsPerMinute = 60;
-const uint64_t kNumSecondsPerHour = kNumSecondsPerMinute * 60;
-const uint64_t kNumSecondsPerWeek = kNumSecondsPerHour * 24 * 7;
-const uint64_t kNumMillisPerSecond = 1000;
-const uint64_t kNumMicrosPerMilli = 1000;
-const uint64_t kNumMicrosPerSecond = kNumMicrosPerMilli * kNumMillisPerSecond;
+inline constexpr uint64_t kNumSecondsPerMinute = 60;
+inline constexpr uint64_t kNumSecondsPerHour = kNumSecondsPerMinute * 60;
+inline constexpr uint64_t kNumSecondsPerWeek = kNumSecondsPerHour * 24 * 7;
+inline constexpr uint64_t kNumMillisPerSecond = 1000;
+inline constexpr uint64_t kNumMicrosPerMilli = 1000;
+inline constexpr uint64_t kNumMicrosPerSecond =
+    kNumMicrosPerMilli * kNumMillisPerSecond;
 
 // Default number of connections for N-connection emulation.
-const uint32_t kDefaultNumConnections = 2;
+inline constexpr uint32_t kDefaultNumConnections = 2;
 // Default initial maximum size in bytes of a QUIC packet.
-const QuicByteCount kDefaultMaxPacketSize = 1250;
+inline constexpr QuicByteCount kDefaultMaxPacketSize = 1250;
 // Default initial maximum size in bytes of a QUIC packet for servers.
-const QuicByteCount kDefaultServerMaxPacketSize = 1000;
+inline constexpr QuicByteCount kDefaultServerMaxPacketSize = 1000;
 // Maximum transmission unit on Ethernet.
-const QuicByteCount kEthernetMTU = 1500;
+inline constexpr QuicByteCount kEthernetMTU = 1500;
 // The maximum packet size of any QUIC packet over IPv6, based on ethernet's max
 // size, minus the IP and UDP headers. IPv6 has a 40 byte header, UDP 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 kMaxV6PacketSize = 1452;
+inline constexpr QuicByteCount kMaxV6PacketSize = 1452;
 // The maximum packet size of any QUIC packet over IPv4.
 // 1500(Ethernet) - 20(IPv4 header) - 8(UDP header) = 1472.
-const QuicByteCount kMaxV4PacketSize = 1472;
+inline constexpr QuicByteCount kMaxV4PacketSize = 1472;
 // The maximum incoming packet size allowed.
-const QuicByteCount kMaxIncomingPacketSize = kMaxV4PacketSize;
+inline constexpr QuicByteCount kMaxIncomingPacketSize = kMaxV4PacketSize;
 // The maximum outgoing packet size allowed.
-const QuicByteCount kMaxOutgoingPacketSize = kMaxV6PacketSize;
+inline constexpr QuicByteCount kMaxOutgoingPacketSize = kMaxV6PacketSize;
 // ETH_MAX_MTU - MAX(sizeof(iphdr), sizeof(ip6_hdr)) - sizeof(udphdr).
-const QuicByteCount kMaxGsoPacketSize = 65535 - 40 - 8;
+inline constexpr QuicByteCount kMaxGsoPacketSize = 65535 - 40 - 8;
 // The maximal IETF DATAGRAM frame size we'll accept. Choosing 2^16 ensures
 // that it is greater than the biggest frame we could ever fit in a QUIC packet.
-const QuicByteCount kMaxAcceptedDatagramFrameSize = 65536;
+inline constexpr QuicByteCount kMaxAcceptedDatagramFrameSize = 65536;
 // Default value of the max_packet_size transport parameter if it is not
 // transmitted.
-const QuicByteCount kDefaultMaxPacketSizeTransportParam = 65527;
+inline constexpr QuicByteCount kDefaultMaxPacketSizeTransportParam = 65527;
 // Default maximum packet size used in the Linux TCP implementation.
 // Used in QUIC for congestion window computations in bytes.
-const QuicByteCount kDefaultTCPMSS = 1460;
-const QuicByteCount kMaxSegmentSize = kDefaultTCPMSS;
+inline constexpr QuicByteCount kDefaultTCPMSS = 1460;
+inline constexpr QuicByteCount kMaxSegmentSize = kDefaultTCPMSS;
 // The minimum size of a packet which can elicit a version negotiation packet,
 // as per section 8.1 of the QUIC spec.
-const QuicByteCount kMinPacketSizeForVersionNegotiation = 1200;
+inline constexpr QuicByteCount kMinPacketSizeForVersionNegotiation = 1200;
 
 // We match SPDY's use of 32 (since we'd compete with SPDY).
-const QuicPacketCount kInitialCongestionWindow = 32;
+inline constexpr QuicPacketCount kInitialCongestionWindow = 32;
 
 // Do not allow initial congestion window to be greater than 200 packets.
-const QuicPacketCount kMaxInitialCongestionWindow = 200;
+inline constexpr QuicPacketCount kMaxInitialCongestionWindow = 200;
 
 // Do not allow initial congestion window to be smaller than 10 packets.
-const QuicPacketCount kMinInitialCongestionWindow = 10;
+inline constexpr QuicPacketCount kMinInitialCongestionWindow = 10;
 
 // Minimum size of initial flow control window, for both stream and session.
 // This is only enforced when version.AllowsLowFlowControlLimits() is false.
-const QuicByteCount kMinimumFlowControlSendWindow = 16 * 1024;  // 16 KB
+inline constexpr QuicByteCount kMinimumFlowControlSendWindow =
+    16 * 1024;  // 16 KB
 // Default size of initial flow control window, for both stream and session.
-const QuicByteCount kDefaultFlowControlSendWindow = 16 * 1024;  // 16 KB
+inline constexpr QuicByteCount kDefaultFlowControlSendWindow =
+    16 * 1024;  // 16 KB
 
 // Maximum flow control receive window limits for connection and stream.
-const QuicByteCount kStreamReceiveWindowLimit = 16 * 1024 * 1024;   // 16 MB
-const QuicByteCount kSessionReceiveWindowLimit = 24 * 1024 * 1024;  // 24 MB
+inline constexpr QuicByteCount kStreamReceiveWindowLimit =
+    16 * 1024 * 1024;  // 16 MB
+inline constexpr QuicByteCount kSessionReceiveWindowLimit =
+    24 * 1024 * 1024;  // 24 MB
 
 // Minimum size of the CWND, in packets, when doing bandwidth resumption.
-const QuicPacketCount kMinCongestionWindowForBandwidthResumption = 10;
+inline constexpr QuicPacketCount kMinCongestionWindowForBandwidthResumption =
+    10;
 
 // Default size of the socket receive buffer in bytes.
-const QuicByteCount kDefaultSocketReceiveBuffer = 1024 * 1024;
+inline constexpr QuicByteCount kDefaultSocketReceiveBuffer = 1024 * 1024;
 
 // The lower bound of an untrusted initial rtt value.
-const uint32_t kMinUntrustedInitialRoundTripTimeUs = 10 * kNumMicrosPerMilli;
+inline constexpr uint32_t kMinUntrustedInitialRoundTripTimeUs =
+    10 * kNumMicrosPerMilli;
 
 // The lower bound of a trusted initial rtt value.
-const uint32_t kMinTrustedInitialRoundTripTimeUs = 5 * kNumMicrosPerMilli;
+inline constexpr uint32_t kMinTrustedInitialRoundTripTimeUs =
+    5 * kNumMicrosPerMilli;
 
 // Don't allow a client to suggest an RTT longer than 1 second.
-const uint32_t kMaxInitialRoundTripTimeUs = kNumMicrosPerSecond;
+inline constexpr uint32_t kMaxInitialRoundTripTimeUs = kNumMicrosPerSecond;
 
 // Maximum number of open streams per connection.
-const size_t kDefaultMaxStreamsPerConnection = 100;
+inline constexpr size_t kDefaultMaxStreamsPerConnection = 100;
 
 // Number of bytes reserved for public flags in the packet header.
-const size_t kPublicFlagsSize = 1;
+inline constexpr size_t kPublicFlagsSize = 1;
 // Number of bytes reserved for version number in the packet header.
-const size_t kQuicVersionSize = 4;
+inline constexpr size_t kQuicVersionSize = 4;
 
 // Minimum number of active connection IDs that an end point can maintain.
-const uint32_t kMinNumOfActiveConnectionIds = 2;
+inline constexpr uint32_t kMinNumOfActiveConnectionIds = 2;
 
 // Length of the retry integrity tag in bytes.
 // https://tools.ietf.org/html/draft-ietf-quic-transport-25#section-17.2.5
-const size_t kRetryIntegrityTagLength = 16;
+inline constexpr size_t kRetryIntegrityTagLength = 16;
 
 // By default, UnackedPacketsMap allocates buffer of 64 after the first packet
 // is added.
-const int kDefaultUnackedPacketsInitialCapacity = 64;
+inline constexpr int kDefaultUnackedPacketsInitialCapacity = 64;
 
 // Signifies that the QuicPacket will contain version of the protocol.
-const bool kIncludeVersion = true;
+inline constexpr bool kIncludeVersion = true;
 // Signifies that the QuicPacket will include a diversification nonce.
-const bool kIncludeDiversificationNonce = true;
+inline constexpr bool kIncludeDiversificationNonce = true;
 
 // Header key used to identify final offset on data stream when sending HTTP/2
 // trailing headers over QUIC.
@@ -126,40 +134,40 @@
 // Default maximum delayed ack time, in ms.
 // Uses a 25ms delayed ack timer. Helps with better signaling
 // in low-bandwidth (< ~384 kbps), where an ack is sent per packet.
-const int64_t kDefaultDelayedAckTimeMs = 25;
+inline constexpr int64_t kDefaultDelayedAckTimeMs = 25;
 
 // Default minimum delayed ack time, in ms (used only for sender control of ack
 // frequency).
-const uint32_t kDefaultMinAckDelayTimeMs = 5;
+inline constexpr uint32_t kDefaultMinAckDelayTimeMs = 5;
 
 // Default shift of the ACK delay in the IETF QUIC ACK frame.
-const uint32_t kDefaultAckDelayExponent = 3;
+inline constexpr uint32_t kDefaultAckDelayExponent = 3;
 
 // Minimum tail loss probe time in ms.
-static const int64_t kMinTailLossProbeTimeoutMs = 10;
+inline constexpr int64_t kMinTailLossProbeTimeoutMs = 10;
 
 // The timeout before the handshake succeeds.
-const int64_t kInitialIdleTimeoutSecs = 5;
+inline constexpr int64_t kInitialIdleTimeoutSecs = 5;
 // The maximum idle timeout that can be negotiated.
-const int64_t kMaximumIdleTimeoutSecs = 60 * 10;  // 10 minutes.
+inline constexpr int64_t kMaximumIdleTimeoutSecs = 60 * 10;  // 10 minutes.
 // The default timeout for a connection until the crypto handshake succeeds.
-const int64_t kMaxTimeForCryptoHandshakeSecs = 10;  // 10 secs.
+inline constexpr int64_t kMaxTimeForCryptoHandshakeSecs = 10;  // 10 secs.
 
 // Default limit on the number of undecryptable packets the connection buffers
 // before the CHLO/SHLO arrive.
-const size_t kDefaultMaxUndecryptablePackets = 10;
+inline constexpr size_t kDefaultMaxUndecryptablePackets = 10;
 
 // Default ping timeout.
-const int64_t kPingTimeoutSecs = 15;  // 15 secs.
+inline constexpr int64_t kPingTimeoutSecs = 15;  // 15 secs.
 
 // Minimum number of RTTs between Server Config Updates (SCUP) sent to client.
-const int kMinIntervalBetweenServerConfigUpdatesRTTs = 10;
+inline constexpr int kMinIntervalBetweenServerConfigUpdatesRTTs = 10;
 
 // Minimum time between Server Config Updates (SCUP) sent to client.
-const int kMinIntervalBetweenServerConfigUpdatesMs = 1000;
+inline constexpr int kMinIntervalBetweenServerConfigUpdatesMs = 1000;
 
 // Minimum number of packets between Server Config Updates (SCUP).
-const int kMinPacketsBetweenServerConfigUpdates = 100;
+inline constexpr int kMinPacketsBetweenServerConfigUpdates = 100;
 
 // The number of open streams that a server will accept is set to be slightly
 // larger than the negotiated limit. Immediately closing the connection if the
@@ -167,31 +175,32 @@
 // a FIN that was lost, and simultaneously opened a new stream. The number of
 // streams a server accepts is a fixed increment over the negotiated limit, or a
 // percentage increase, whichever is larger.
-const float kMaxStreamsMultiplier = 1.1f;
-const int kMaxStreamsMinimumIncrement = 10;
+inline constexpr float kMaxStreamsMultiplier = 1.1f;
+inline constexpr int kMaxStreamsMinimumIncrement = 10;
 
 // Available streams are ones with IDs less than the highest stream that has
 // been opened which have neither been opened or reset. The limit on the number
 // of available streams is 10 times the limit on the number of open streams.
-const int kMaxAvailableStreamsMultiplier = 10;
+inline constexpr int kMaxAvailableStreamsMultiplier = 10;
 
 // Track the number of promises that are not yet claimed by a
 // corresponding get.  This must be smaller than
 // kMaxAvailableStreamsMultiplier, because RST on a promised stream my
 // create available streams entries.
-const int kMaxPromisedStreamsMultiplier = kMaxAvailableStreamsMultiplier - 1;
+inline constexpr int kMaxPromisedStreamsMultiplier =
+    kMaxAvailableStreamsMultiplier - 1;
 
 // The 1st PTO is armed with max of earliest in flight sent time + PTO
 // delay and kFirstPtoSrttMultiplier * srtt from last in flight packet.
-const float kFirstPtoSrttMultiplier = 1.5;
+inline constexpr float kFirstPtoSrttMultiplier = 1.5;
 
 // The multiplier of RTT variation when calculating PTO timeout.
-const int kPtoRttvarMultiplier = 2;
+inline constexpr int kPtoRttvarMultiplier = 2;
 
 // TCP RFC calls for 1 second RTO however Linux differs from this default and
 // define the minimum RTO to 200ms, we will use the same until we have data to
 // support a higher or lower value.
-static const int64_t kMinRetransmissionTimeMs = 200;
+inline constexpr const int64_t kMinRetransmissionTimeMs = 200;
 // The delayed ack time must not be greater than half the min RTO.
 static_assert(kDefaultDelayedAckTimeMs <= kMinRetransmissionTimeMs / 2,
               "Delayed ack time must be less than or equal half the MinRTO");
@@ -205,98 +214,101 @@
 //   uint64_t value;
 //   if (exponent == 0) value = mantissa;
 //   else value = (mantissa | 1 << 11) << (exponent - 1)
-const int kUFloat16ExponentBits = 5;
-const int kUFloat16MaxExponent = (1 << kUFloat16ExponentBits) - 2;     // 30
-const int kUFloat16MantissaBits = 16 - kUFloat16ExponentBits;          // 11
-const int kUFloat16MantissaEffectiveBits = kUFloat16MantissaBits + 1;  // 12
-const uint64_t kUFloat16MaxValue =  // 0x3FFC0000000
+inline constexpr int kUFloat16ExponentBits = 5;
+inline constexpr int kUFloat16MaxExponent =
+    (1 << kUFloat16ExponentBits) - 2;                                     // 30
+inline constexpr int kUFloat16MantissaBits = 16 - kUFloat16ExponentBits;  // 11
+inline constexpr int kUFloat16MantissaEffectiveBits =
+    kUFloat16MantissaBits + 1;                 // 12
+inline constexpr uint64_t kUFloat16MaxValue =  // 0x3FFC0000000
     ((UINT64_C(1) << kUFloat16MantissaEffectiveBits) - 1)
     << kUFloat16MaxExponent;
 
 // kDiversificationNonceSize is the size, in bytes, of the nonce that a server
 // may set in the packet header to ensure that its INITIAL keys are not
 // duplicated.
-const size_t kDiversificationNonceSize = 32;
+inline constexpr size_t kDiversificationNonceSize = 32;
 
 // The largest gap in packets we'll accept without closing the connection.
 // This will likely have to be tuned.
-const QuicPacketCount kMaxPacketGap = 5000;
+inline constexpr QuicPacketCount kMaxPacketGap = 5000;
 
 // The max number of sequence number intervals that
 // QuicPeerIssuedConnetionIdManager can maintain.
-const size_t kMaxNumConnectionIdSequenceNumberIntervals = 20;
+inline constexpr size_t kMaxNumConnectionIdSequenceNumberIntervals = 20;
 
 // The maximum number of random padding bytes to add.
-const QuicByteCount kMaxNumRandomPaddingBytes = 256;
+inline constexpr QuicByteCount kMaxNumRandomPaddingBytes = 256;
 
 // The size of stream send buffer data slice size in bytes. A data slice is
 // piece of stream data stored in contiguous memory, and a stream frame can
 // contain data from multiple data slices.
-const QuicByteCount kQuicStreamSendBufferSliceSize = 4 * 1024;
+inline constexpr QuicByteCount kQuicStreamSendBufferSliceSize = 4 * 1024;
 
 // For When using Random Initial Packet Numbers, they can start
 // anyplace in the range 1...((2^31)-1) or 0x7fffffff
 QUIC_EXPORT_PRIVATE QuicPacketNumber MaxRandomInitialPacketNumber();
 
 // Used to represent an invalid or no control frame id.
-const QuicControlFrameId kInvalidControlFrameId = 0;
+inline constexpr QuicControlFrameId kInvalidControlFrameId = 0;
 
 // The max length a stream can have.
-const QuicByteCount kMaxStreamLength = (UINT64_C(1) << 62) - 1;
+inline constexpr QuicByteCount kMaxStreamLength = (UINT64_C(1) << 62) - 1;
 
 // The max value that can be encoded using IETF Var Ints.
-const uint64_t kMaxIetfVarInt = UINT64_C(0x3fffffffffffffff);
+inline constexpr uint64_t kMaxIetfVarInt = UINT64_C(0x3fffffffffffffff);
 
 // The maximum stream id value that is supported - (2^32)-1
-const QuicStreamId kMaxQuicStreamId = 0xffffffff;
+inline constexpr QuicStreamId kMaxQuicStreamId = 0xffffffff;
 
 // The maximum value that can be stored in a 32-bit QuicStreamCount.
-const QuicStreamCount kMaxQuicStreamCount = 0xffffffff;
+inline constexpr QuicStreamCount kMaxQuicStreamCount = 0xffffffff;
 
 // Number of bytes reserved for packet header type.
-const size_t kPacketHeaderTypeSize = 1;
+inline constexpr size_t kPacketHeaderTypeSize = 1;
 
 // Number of bytes reserved for connection ID length.
-const size_t kConnectionIdLengthSize = 1;
+inline constexpr size_t kConnectionIdLengthSize = 1;
 
 // Minimum length of random bytes in IETF stateless reset packet.
-const size_t kMinRandomBytesLengthInStatelessReset = 24;
+inline constexpr size_t kMinRandomBytesLengthInStatelessReset = 24;
 
 // Maximum length allowed for the token in a NEW_TOKEN frame.
-const size_t kMaxNewTokenTokenLength = 0xffff;
+inline constexpr size_t kMaxNewTokenTokenLength = 0xffff;
 
 // The prefix used by a source address token in a NEW_TOKEN frame.
-const uint8_t kAddressTokenPrefix = 0;
+inline constexpr uint8_t kAddressTokenPrefix = 0;
 
 // Default initial rtt used before any samples are received.
-const int kInitialRttMs = 100;
+inline constexpr int kInitialRttMs = 100;
 
 // Default threshold of packet reordering before a packet is declared lost.
-static const QuicPacketCount kDefaultPacketReorderingThreshold = 3;
+inline constexpr QuicPacketCount kDefaultPacketReorderingThreshold = 3;
 
 // Default fraction (1/4) of an RTT the algorithm waits before determining a
 // packet is lost due to early retransmission by time based loss detection.
-static const int kDefaultLossDelayShift = 2;
+inline constexpr int kDefaultLossDelayShift = 2;
 
 // Default fraction (1/8) of an RTT when doing IETF loss detection.
-static const int kDefaultIetfLossDelayShift = 3;
+inline constexpr int kDefaultIetfLossDelayShift = 3;
 
 // Maximum number of retransmittable packets received before sending an ack.
-const QuicPacketCount kDefaultRetransmittablePacketsBeforeAck = 2;
+inline constexpr QuicPacketCount kDefaultRetransmittablePacketsBeforeAck = 2;
 // Wait for up to 10 retransmittable packets before sending an ack.
-const QuicPacketCount kMaxRetransmittablePacketsBeforeAck = 10;
+inline constexpr QuicPacketCount kMaxRetransmittablePacketsBeforeAck = 10;
 // Minimum number of packets received before ack decimation is enabled.
 // This intends to avoid the beginning of slow start, when CWNDs may be
 // rapidly increasing.
-const QuicPacketCount kMinReceivedBeforeAckDecimation = 100;
+inline constexpr QuicPacketCount kMinReceivedBeforeAckDecimation = 100;
 // One quarter RTT delay when doing ack decimation.
-const float kAckDecimationDelay = 0.25;
+inline constexpr float kAckDecimationDelay = 0.25;
 
 // The default alarm granularity assumed by QUIC code.
-const QuicTime::Delta kAlarmGranularity = QuicTime::Delta::FromMilliseconds(1);
+inline constexpr QuicTime::Delta kAlarmGranularity =
+    QuicTime::Delta::FromMilliseconds(1);
 
 // Maximum number of unretired connection IDs a connection can have.
-const size_t kMaxNumConnectonIdsInUse = 10u;
+inline constexpr size_t kMaxNumConnectonIdsInUse = 10u;
 
 // Packet number of first sending packet of a connection. Please note, this
 // cannot be used as first received packet because peer can choose its starting
@@ -307,9 +319,7 @@
 QUIC_EXPORT_PRIVATE extern const char* const kEPIDGoogleFrontEnd;
 QUIC_EXPORT_PRIVATE extern const char* const kEPIDGoogleFrontEnd0;
 
-enum : uint64_t {
-  kHttpDatagramStreamIdDivisor = 4,
-};
+inline constexpr uint64_t kHttpDatagramStreamIdDivisor = 4;
 
 }  // namespace quic