diff --git a/quiche/quic/core/quic_connection_id.cc b/quiche/quic/core/quic_connection_id.cc
index c87eaf6..839097d 100644
--- a/quiche/quic/core/quic_connection_id.cc
+++ b/quiche/quic/core/quic_connection_id.cc
@@ -174,7 +174,7 @@
 
 static_assert(kQuicDefaultConnectionIdLength == sizeof(uint64_t),
               "kQuicDefaultConnectionIdLength changed");
-static_assert(kQuicDefaultConnectionIdLength == PACKET_8BYTE_CONNECTION_ID,
+static_assert(kQuicDefaultConnectionIdLength == 8,
               "kQuicDefaultConnectionIdLength changed");
 
 }  // namespace quic
diff --git a/quiche/quic/core/quic_connection_id.h b/quiche/quic/core/quic_connection_id.h
index 52f1501..4994349 100644
--- a/quiche/quic/core/quic_connection_id.h
+++ b/quiche/quic/core/quic_connection_id.h
@@ -13,11 +13,6 @@
 
 namespace quic {
 
-enum QuicConnectionIdLength {
-  PACKET_0BYTE_CONNECTION_ID = 0,
-  PACKET_8BYTE_CONNECTION_ID = 8,
-};
-
 // This is a property of QUIC headers, it indicates whether the connection ID
 // should actually be sent over the wire (or was sent on received packets).
 enum QuicConnectionIdIncluded : uint8_t {
diff --git a/quiche/quic/core/quic_crypto_stream.cc b/quiche/quic/core/quic_crypto_stream.cc
index 7009920..31c2180 100644
--- a/quiche/quic/core/quic_crypto_stream.cc
+++ b/quiche/quic/core/quic_crypto_stream.cc
@@ -58,9 +58,7 @@
     length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
   }
   return QuicPacketCreator::StreamFramePacketOverhead(
-      version, static_cast<QuicConnectionIdLength>(connection_id.length()),
-      PACKET_0BYTE_CONNECTION_ID,
-      /*include_version=*/true,
+      version, connection_id.length(), 0, /*include_version=*/true,
       /*include_diversification_nonce=*/true,
       VersionHasIetfInvariantHeader(version) ? PACKET_4BYTE_PACKET_NUMBER
                                              : PACKET_1BYTE_PACKET_NUMBER,
diff --git a/quiche/quic/core/quic_framer.cc b/quiche/quic/core/quic_framer.cc
index db7100d..2c7860f 100644
--- a/quiche/quic/core/quic_framer.cc
+++ b/quiche/quic/core/quic_framer.cc
@@ -311,7 +311,7 @@
   return kMaxErrorStringLength;
 }
 
-uint8_t GetConnectionIdLengthValue(QuicConnectionIdLength length) {
+uint8_t GetConnectionIdLengthValue(uint8_t length) {
   if (length == 0) {
     return 0;
   }
@@ -343,10 +343,8 @@
   }
 
   // Compute connection ID length byte.
-  uint8_t dcil = GetConnectionIdLengthValue(
-      static_cast<QuicConnectionIdLength>(destination_connection_id.length()));
-  uint8_t scil = GetConnectionIdLengthValue(
-      static_cast<QuicConnectionIdLength>(source_connection_id.length()));
+  uint8_t dcil = GetConnectionIdLengthValue(destination_connection_id.length());
+  uint8_t scil = GetConnectionIdLengthValue(source_connection_id.length());
   uint8_t connection_id_length = dcil << 4 | scil;
 
   return writer->WriteUInt8(connection_id_length) &&
@@ -4390,8 +4388,8 @@
 // static
 absl::string_view QuicFramer::GetAssociatedDataFromEncryptedPacket(
     QuicTransportVersion version, const QuicEncryptedPacket& encrypted,
-    QuicConnectionIdLength destination_connection_id_length,
-    QuicConnectionIdLength source_connection_id_length, bool includes_version,
+    uint8_t destination_connection_id_length,
+    uint8_t source_connection_id_length, bool includes_version,
     bool includes_diversification_nonce,
     QuicPacketNumberLength packet_number_length,
     quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
diff --git a/quiche/quic/core/quic_framer.h b/quiche/quic/core/quic_framer.h
index 694e741..4552693 100644
--- a/quiche/quic/core/quic_framer.h
+++ b/quiche/quic/core/quic_framer.h
@@ -421,8 +421,8 @@
   // stringpiece.
   static absl::string_view GetAssociatedDataFromEncryptedPacket(
       QuicTransportVersion version, const QuicEncryptedPacket& encrypted,
-      QuicConnectionIdLength destination_connection_id_length,
-      QuicConnectionIdLength source_connection_id_length, bool includes_version,
+      uint8_t destination_connection_id_length,
+      uint8_t source_connection_id_length, bool includes_version,
       bool includes_diversification_nonce,
       QuicPacketNumberLength packet_number_length,
       quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
diff --git a/quiche/quic/core/quic_framer_test.cc b/quiche/quic/core/quic_framer_test.cc
index 99c29dc..16f44a5 100644
--- a/quiche/quic/core/quic_framer_test.cc
+++ b/quiche/quic/core/quic_framer_test.cc
@@ -49,6 +49,8 @@
 
 const uint64_t kEpoch = UINT64_C(1) << 32;
 const uint64_t kMask = kEpoch - 1;
+const uint8_t kPacket0ByteConnectionId = 0;
+const uint8_t kPacket8ByteConnectionId = 8;
 
 const StatelessResetToken kTestStatelessResetToken{
     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
@@ -761,8 +763,8 @@
   bool CheckDecryption(const QuicEncryptedPacket& encrypted,
                        bool includes_version,
                        bool includes_diversification_nonce,
-                       QuicConnectionIdLength destination_connection_id_length,
-                       QuicConnectionIdLength source_connection_id_length) {
+                       uint8_t destination_connection_id_length,
+                       uint8_t source_connection_id_length) {
     return CheckDecryption(
         encrypted, includes_version, includes_diversification_nonce,
         destination_connection_id_length, source_connection_id_length,
@@ -773,8 +775,8 @@
   bool CheckDecryption(
       const QuicEncryptedPacket& encrypted, bool includes_version,
       bool includes_diversification_nonce,
-      QuicConnectionIdLength destination_connection_id_length,
-      QuicConnectionIdLength source_connection_id_length,
+      uint8_t destination_connection_id_length,
+      uint8_t source_connection_id_length,
       quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
       size_t retry_token_length,
       quiche::QuicheVariableLengthIntegerLength length_length) {
@@ -1082,10 +1084,9 @@
   }
 
   const size_t header_size = GetPacketHeaderSize(
-      framer_.transport_version(), PACKET_8BYTE_CONNECTION_ID,
-      PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
-      !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
-      quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+      framer_.transport_version(), kPacket8ByteConnectionId,
+      kPacket0ByteConnectionId, !kIncludeVersion, !kIncludeDiversificationNonce,
+      PACKET_4BYTE_PACKET_NUMBER, quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
       quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
 
   memset(p + header_size, 0, kMaxIncomingPacketSize - header_size);
@@ -2231,7 +2232,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
@@ -2350,7 +2351,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
@@ -2405,7 +2406,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
@@ -2554,7 +2555,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
@@ -2673,7 +2674,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
@@ -2792,7 +2793,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
@@ -2995,7 +2996,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID,
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId,
       retry_token_length_length, retry_token_length, length_length));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
@@ -3078,7 +3079,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   ASSERT_EQ(0u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
@@ -3225,7 +3226,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
@@ -3718,7 +3719,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
@@ -3825,7 +3826,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
@@ -4061,7 +4062,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
@@ -4589,7 +4590,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.stop_waiting_frames_.size());
@@ -4736,7 +4737,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(kStreamId, visitor_.rst_stream_frame_.stream_id);
   EXPECT_EQ(QUIC_STREAM_CANCELLED, visitor_.rst_stream_frame_.error_code);
@@ -4847,7 +4848,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   EXPECT_EQ(0x11u, static_cast<unsigned>(
@@ -4972,7 +4973,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details);
@@ -5102,7 +5103,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   EXPECT_EQ(0x11u, static_cast<unsigned>(
@@ -5172,7 +5173,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
 
@@ -5234,7 +5235,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
 
@@ -5331,7 +5332,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(kStreamId, visitor_.goaway_frame_.last_good_stream_id);
   EXPECT_EQ(0x9u, visitor_.goaway_frame_.error_code);
@@ -5422,7 +5423,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(kStreamId, visitor_.goaway_frame_.last_good_stream_id);
   EXPECT_EQ(0xC0DE, visitor_.goaway_frame_.error_code);
@@ -5495,7 +5496,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(kStreamId, visitor_.window_update_frame_.stream_id);
   EXPECT_EQ(kStreamOffset, visitor_.window_update_frame_.max_data);
@@ -5538,7 +5539,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(QuicUtils::GetInvalidStreamId(framer_.transport_version()),
             visitor_.window_update_frame_.stream_id);
@@ -5585,7 +5586,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(kStreamId, visitor_.window_update_frame_.stream_id);
   EXPECT_EQ(kStreamOffset, visitor_.window_update_frame_.max_data);
@@ -5666,7 +5667,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     EXPECT_EQ(kStreamOffset, visitor_.blocked_frame_.offset);
@@ -5739,7 +5740,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(1u, visitor_.ping_frames_.size());
 
@@ -5773,7 +5774,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(1u, visitor_.handshake_done_frames_.size());
 }
@@ -5813,7 +5814,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   ASSERT_EQ(1u, visitor_.ack_frequency_frames_.size());
   const auto& frame = visitor_.ack_frequency_frames_.front();
@@ -5895,7 +5896,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   ASSERT_EQ(2u, visitor_.message_frames_.size());
   EXPECT_EQ(7u, visitor_.message_frames_[0]->message_length);
@@ -6555,10 +6556,9 @@
   }
 
   uint64_t header_size = GetPacketHeaderSize(
-      framer_.transport_version(), PACKET_8BYTE_CONNECTION_ID,
-      PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
-      !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
-      quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+      framer_.transport_version(), kPacket8ByteConnectionId,
+      kPacket0ByteConnectionId, !kIncludeVersion, !kIncludeDiversificationNonce,
+      PACKET_4BYTE_PACKET_NUMBER, quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
       quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
   memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
 
@@ -6745,10 +6745,9 @@
   }
 
   uint64_t header_size = GetPacketHeaderSize(
-      framer_.transport_version(), PACKET_8BYTE_CONNECTION_ID,
-      PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
-      !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
-      quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+      framer_.transport_version(), kPacket8ByteConnectionId,
+      kPacket0ByteConnectionId, !kIncludeVersion, !kIncludeDiversificationNonce,
+      PACKET_4BYTE_PACKET_NUMBER, quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
       quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
   memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
 
@@ -6821,10 +6820,9 @@
   }
 
   uint64_t header_size = GetPacketHeaderSize(
-      framer_.transport_version(), PACKET_8BYTE_CONNECTION_ID,
-      PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
-      !kIncludeDiversificationNonce, PACKET_2BYTE_PACKET_NUMBER,
-      quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+      framer_.transport_version(), kPacket8ByteConnectionId,
+      kPacket0ByteConnectionId, !kIncludeVersion, !kIncludeDiversificationNonce,
+      PACKET_2BYTE_PACKET_NUMBER, quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
       quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
   memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
 
@@ -6897,10 +6895,9 @@
   }
 
   uint64_t header_size = GetPacketHeaderSize(
-      framer_.transport_version(), PACKET_8BYTE_CONNECTION_ID,
-      PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
-      !kIncludeDiversificationNonce, PACKET_1BYTE_PACKET_NUMBER,
-      quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+      framer_.transport_version(), kPacket8ByteConnectionId,
+      kPacket0ByteConnectionId, !kIncludeVersion, !kIncludeDiversificationNonce,
+      PACKET_1BYTE_PACKET_NUMBER, quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
       quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
   memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
 
@@ -7297,7 +7294,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
   ASSERT_EQ(1u, visitor_.crypto_frames_.size());
   QuicCryptoFrame* frame = visitor_.crypto_frames_[0].get();
   EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, frame->level);
@@ -10470,12 +10467,11 @@
     p = packet46;
   }
 
-  std::unique_ptr<QuicPacket> raw(
-      new QuicPacket(AsChars(p), p_size, false, PACKET_8BYTE_CONNECTION_ID,
-                     PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
-                     !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
-                     quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
-                     quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0));
+  std::unique_ptr<QuicPacket> raw(new QuicPacket(
+      AsChars(p), p_size, false, kPacket8ByteConnectionId,
+      kPacket0ByteConnectionId, !kIncludeVersion, !kIncludeDiversificationNonce,
+      PACKET_4BYTE_PACKET_NUMBER, quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+      quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0));
   char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length = framer_.EncryptPayload(
       ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxOutgoingPacketSize);
@@ -10487,8 +10483,8 @@
 // Regression test for b/158014497.
 TEST_P(QuicFramerTest, EncryptEmptyPacket) {
   auto packet = std::make_unique<QuicPacket>(
-      new char[100], 0, true, PACKET_8BYTE_CONNECTION_ID,
-      PACKET_0BYTE_CONNECTION_ID,
+      new char[100], 0, true, kPacket8ByteConnectionId,
+      kPacket0ByteConnectionId,
       /*includes_version=*/true,
       /*includes_diversification_nonce=*/true, PACKET_1BYTE_PACKET_NUMBER,
       quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
@@ -10579,12 +10575,11 @@
     p_size = ABSL_ARRAYSIZE(packet46);
   }
 
-  std::unique_ptr<QuicPacket> raw(
-      new QuicPacket(AsChars(p), p_size, false, PACKET_8BYTE_CONNECTION_ID,
-                     PACKET_0BYTE_CONNECTION_ID, kIncludeVersion,
-                     !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
-                     quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
-                     quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0));
+  std::unique_ptr<QuicPacket> raw(new QuicPacket(
+      AsChars(p), p_size, false, kPacket8ByteConnectionId,
+      kPacket0ByteConnectionId, kIncludeVersion, !kIncludeDiversificationNonce,
+      PACKET_4BYTE_PACKET_NUMBER, quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+      quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0));
   char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length = framer_.EncryptPayload(
       ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxOutgoingPacketSize);
@@ -11049,7 +11044,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(kStreamOffset, visitor_.blocked_frame_.offset);
 
@@ -11134,7 +11129,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(kStreamId, visitor_.blocked_frame_.stream_id);
   EXPECT_EQ(kStreamOffset, visitor_.blocked_frame_.offset);
@@ -11220,7 +11215,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(3u, visitor_.max_streams_frame_.stream_count);
   EXPECT_FALSE(visitor_.max_streams_frame_.unidirectional);
@@ -11261,7 +11256,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_0BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket0ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(3u, visitor_.max_streams_frame_.stream_count);
   EXPECT_TRUE(visitor_.max_streams_frame_.unidirectional);
@@ -11303,7 +11298,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(3u, visitor_.max_streams_frame_.stream_count);
   EXPECT_TRUE(visitor_.max_streams_frame_.unidirectional);
@@ -11344,7 +11339,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_0BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket0ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(3u, visitor_.max_streams_frame_.stream_count);
   EXPECT_TRUE(visitor_.max_streams_frame_.unidirectional);
@@ -11389,7 +11384,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0x40000000u, visitor_.max_streams_frame_.stream_count);
   EXPECT_FALSE(visitor_.max_streams_frame_.unidirectional);
@@ -11428,7 +11423,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_0BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket0ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0x40000000u, visitor_.max_streams_frame_.stream_count);
   EXPECT_FALSE(visitor_.max_streams_frame_.unidirectional);
@@ -11467,7 +11462,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0x40000000u, visitor_.max_streams_frame_.stream_count);
   EXPECT_TRUE(visitor_.max_streams_frame_.unidirectional);
@@ -11506,7 +11501,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_0BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket0ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0x40000000u, visitor_.max_streams_frame_.stream_count);
   EXPECT_TRUE(visitor_.max_streams_frame_.unidirectional);
@@ -11575,7 +11570,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.max_streams_frame_.stream_count);
   EXPECT_TRUE(visitor_.max_streams_frame_.unidirectional);
@@ -11619,7 +11614,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(3u, visitor_.streams_blocked_frame_.stream_count);
   EXPECT_FALSE(visitor_.streams_blocked_frame_.unidirectional);
@@ -11663,7 +11658,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(3u, visitor_.streams_blocked_frame_.stream_count);
   EXPECT_TRUE(visitor_.streams_blocked_frame_.unidirectional);
@@ -11705,7 +11700,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_0BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket0ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(3u, visitor_.streams_blocked_frame_.stream_count);
   EXPECT_TRUE(visitor_.streams_blocked_frame_.unidirectional);
@@ -11788,7 +11783,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.streams_blocked_frame_.stream_count);
   EXPECT_TRUE(visitor_.streams_blocked_frame_.unidirectional);
@@ -12010,7 +12005,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
 
@@ -12069,7 +12064,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
 
@@ -12274,7 +12269,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
 
@@ -12368,7 +12363,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(kStreamId, visitor_.stop_sending_frame_.stream_id);
   EXPECT_EQ(QUIC_STREAM_UNKNOWN_APPLICATION_ERROR_CODE,
@@ -12459,7 +12454,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(QuicPathFrameBuffer({{0, 1, 2, 3, 4, 5, 6, 7}}),
             visitor_.path_challenge_frame_.data_buffer);
@@ -12542,7 +12537,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(QuicPathFrameBuffer({{0, 1, 2, 3, 4, 5, 6, 7}}),
             visitor_.path_response_frame_.data_buffer);
@@ -13344,7 +13339,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
+      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
 
diff --git a/quiche/quic/core/quic_packet_creator.cc b/quiche/quic/core/quic_packet_creator.cc
index d7949ce..6f29e52 100644
--- a/quiche/quic/core/quic_packet_creator.cc
+++ b/quiche/quic/core/quic_packet_creator.cc
@@ -379,9 +379,8 @@
 
 // static
 size_t QuicPacketCreator::StreamFramePacketOverhead(
-    QuicTransportVersion version,
-    QuicConnectionIdLength destination_connection_id_length,
-    QuicConnectionIdLength source_connection_id_length, bool include_version,
+    QuicTransportVersion version, uint8_t destination_connection_id_length,
+    uint8_t source_connection_id_length, bool include_version,
     bool include_diversification_nonce,
     QuicPacketNumberLength packet_number_length,
     quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
@@ -1207,25 +1206,22 @@
   return CONNECTION_ID_ABSENT;
 }
 
-QuicConnectionIdLength QuicPacketCreator::GetDestinationConnectionIdLength()
-    const {
+uint8_t QuicPacketCreator::GetDestinationConnectionIdLength() const {
   QUICHE_DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
                                                          transport_version()))
       << ENDPOINT;
   return GetDestinationConnectionIdIncluded() == CONNECTION_ID_PRESENT
-             ? static_cast<QuicConnectionIdLength>(
-                   GetDestinationConnectionId().length())
-             : PACKET_0BYTE_CONNECTION_ID;
+             ? GetDestinationConnectionId().length()
+             : 0;
 }
 
-QuicConnectionIdLength QuicPacketCreator::GetSourceConnectionIdLength() const {
+uint8_t QuicPacketCreator::GetSourceConnectionIdLength() const {
   QUICHE_DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
                                                          transport_version()))
       << ENDPOINT;
   return GetSourceConnectionIdIncluded() == CONNECTION_ID_PRESENT
-             ? static_cast<QuicConnectionIdLength>(
-                   GetSourceConnectionId().length())
-             : PACKET_0BYTE_CONNECTION_ID;
+             ? GetSourceConnectionId().length()
+             : 0;
 }
 
 QuicPacketNumberLength QuicPacketCreator::GetPacketNumberLength() const {
diff --git a/quiche/quic/core/quic_packet_creator.h b/quiche/quic/core/quic_packet_creator.h
index c6b41ad..0bcd745 100644
--- a/quiche/quic/core/quic_packet_creator.h
+++ b/quiche/quic/core/quic_packet_creator.h
@@ -141,9 +141,8 @@
 
   // The overhead the framing will add for a packet with one frame.
   static size_t StreamFramePacketOverhead(
-      QuicTransportVersion version,
-      QuicConnectionIdLength destination_connection_id_length,
-      QuicConnectionIdLength source_connection_id_length, bool include_version,
+      QuicTransportVersion version, uint8_t destination_connection_id_length,
+      uint8_t source_connection_id_length, bool include_version,
       bool include_diversification_nonce,
       QuicPacketNumberLength packet_number_length,
       quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
@@ -286,10 +285,10 @@
   QuicConnectionId GetSourceConnectionId() const;
 
   // Returns length of destination connection ID to send over the wire.
-  QuicConnectionIdLength GetDestinationConnectionIdLength() const;
+  uint8_t GetDestinationConnectionIdLength() const;
 
   // Returns length of source connection ID to send over the wire.
-  QuicConnectionIdLength GetSourceConnectionIdLength() const;
+  uint8_t GetSourceConnectionIdLength() const;
 
   // Sets whether the server connection ID should be sent over the wire.
   void SetServerConnectionIdIncluded(
diff --git a/quiche/quic/core/quic_packet_creator_test.cc b/quiche/quic/core/quic_packet_creator_test.cc
index 9bd3b2f..b3a5b85 100644
--- a/quiche/quic/core/quic_packet_creator_test.cc
+++ b/quiche/quic/core/quic_packet_creator_test.cc
@@ -3331,17 +3331,14 @@
 TEST_F(QuicPacketCreatorMultiplePacketsTest, TestConnectionIdLength) {
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
   creator_.SetServerConnectionIdLength(0);
-  EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID,
-            creator_.GetDestinationConnectionIdLength());
+  EXPECT_EQ(0, creator_.GetDestinationConnectionIdLength());
 
   for (size_t i = 1; i < 10; i++) {
     creator_.SetServerConnectionIdLength(i);
     if (framer_.version().HasIetfInvariantHeader()) {
-      EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID,
-                creator_.GetDestinationConnectionIdLength());
+      EXPECT_EQ(0, creator_.GetDestinationConnectionIdLength());
     } else {
-      EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID,
-                creator_.GetDestinationConnectionIdLength());
+      EXPECT_EQ(8, creator_.GetDestinationConnectionIdLength());
     }
   }
 }
diff --git a/quiche/quic/core/quic_packets.cc b/quiche/quic/core/quic_packets.cc
index f0b9ccd..b0f7535 100644
--- a/quiche/quic/core/quic_packets.cc
+++ b/quiche/quic/core/quic_packets.cc
@@ -66,25 +66,24 @@
   return header.destination_connection_id_included;
 }
 
-QuicConnectionIdLength GetIncludedConnectionIdLength(
+uint8_t GetIncludedConnectionIdLength(
     QuicConnectionId connection_id,
     QuicConnectionIdIncluded connection_id_included) {
   QUICHE_DCHECK(connection_id_included == CONNECTION_ID_PRESENT ||
                 connection_id_included == CONNECTION_ID_ABSENT);
   return connection_id_included == CONNECTION_ID_PRESENT
-             ? static_cast<QuicConnectionIdLength>(connection_id.length())
-             : PACKET_0BYTE_CONNECTION_ID;
+             ? connection_id.length()
+             : 0;
 }
 
-QuicConnectionIdLength GetIncludedDestinationConnectionIdLength(
+uint8_t GetIncludedDestinationConnectionIdLength(
     const QuicPacketHeader& header) {
   return GetIncludedConnectionIdLength(
       header.destination_connection_id,
       header.destination_connection_id_included);
 }
 
-QuicConnectionIdLength GetIncludedSourceConnectionIdLength(
-    const QuicPacketHeader& header) {
+uint8_t GetIncludedSourceConnectionIdLength(const QuicPacketHeader& header) {
   return GetIncludedConnectionIdLength(header.source_connection_id,
                                        header.source_connection_id_included);
 }
@@ -100,9 +99,8 @@
 }
 
 size_t GetPacketHeaderSize(
-    QuicTransportVersion version,
-    QuicConnectionIdLength destination_connection_id_length,
-    QuicConnectionIdLength source_connection_id_length, bool include_version,
+    QuicTransportVersion version, uint8_t destination_connection_id_length,
+    uint8_t source_connection_id_length, bool include_version,
     bool include_diversification_nonce,
     QuicPacketNumberLength packet_number_length,
     quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
@@ -148,9 +146,8 @@
 }
 
 size_t GetStartOfEncryptedData(
-    QuicTransportVersion version,
-    QuicConnectionIdLength destination_connection_id_length,
-    QuicConnectionIdLength source_connection_id_length, bool include_version,
+    QuicTransportVersion version, uint8_t destination_connection_id_length,
+    uint8_t source_connection_id_length, bool include_version,
     bool include_diversification_nonce,
     QuicPacketNumberLength packet_number_length,
     quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
@@ -282,8 +279,8 @@
 
 QuicPacket::QuicPacket(
     char* buffer, size_t length, bool owns_buffer,
-    QuicConnectionIdLength destination_connection_id_length,
-    QuicConnectionIdLength source_connection_id_length, bool includes_version,
+    uint8_t destination_connection_id_length,
+    uint8_t source_connection_id_length, bool includes_version,
     bool includes_diversification_nonce,
     QuicPacketNumberLength packet_number_length,
     quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
diff --git a/quiche/quic/core/quic_packets.h b/quiche/quic/core/quic_packets.h
index c0cc8af..263bdb9 100644
--- a/quiche/quic/core/quic_packets.h
+++ b/quiche/quic/core/quic_packets.h
@@ -5,6 +5,8 @@
 #ifndef QUICHE_QUIC_CORE_QUIC_PACKETS_H_
 #define QUICHE_QUIC_CORE_QUIC_PACKETS_H_
 
+#include <sys/types.h>
+
 #include <cstddef>
 #include <cstdint>
 #include <memory>
@@ -64,18 +66,18 @@
                                       Perspective perspective);
 
 // Number of connection ID bytes that are actually included over the wire.
-QUIC_EXPORT_PRIVATE QuicConnectionIdLength
+QUIC_EXPORT_PRIVATE uint8_t
 GetIncludedConnectionIdLength(QuicConnectionId connection_id,
                               QuicConnectionIdIncluded connection_id_included);
 
 // Number of destination connection ID bytes that are actually included over the
 // wire for this particular header.
-QUIC_EXPORT_PRIVATE QuicConnectionIdLength
+QUIC_EXPORT_PRIVATE uint8_t
 GetIncludedDestinationConnectionIdLength(const QuicPacketHeader& header);
 
 // Number of source connection ID bytes that are actually included over the
 // wire for this particular header.
-QUIC_EXPORT_PRIVATE QuicConnectionIdLength
+QUIC_EXPORT_PRIVATE uint8_t
 GetIncludedSourceConnectionIdLength(const QuicPacketHeader& header);
 
 // Size in bytes of the data packet header.
@@ -83,9 +85,8 @@
                                                const QuicPacketHeader& header);
 
 QUIC_EXPORT_PRIVATE size_t GetPacketHeaderSize(
-    QuicTransportVersion version,
-    QuicConnectionIdLength destination_connection_id_length,
-    QuicConnectionIdLength source_connection_id_length, bool include_version,
+    QuicTransportVersion version, uint8_t destination_connection_id_length,
+    uint8_t source_connection_id_length, bool include_version,
     bool include_diversification_nonce,
     QuicPacketNumberLength packet_number_length,
     quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
@@ -97,9 +98,8 @@
     QuicTransportVersion version, const QuicPacketHeader& header);
 
 QUIC_EXPORT_PRIVATE size_t GetStartOfEncryptedData(
-    QuicTransportVersion version,
-    QuicConnectionIdLength destination_connection_id_length,
-    QuicConnectionIdLength source_connection_id_length, bool include_version,
+    QuicTransportVersion version, uint8_t destination_connection_id_length,
+    uint8_t source_connection_id_length, bool include_version,
     bool include_diversification_nonce,
     QuicPacketNumberLength packet_number_length,
     quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
@@ -224,8 +224,8 @@
  public:
   QuicPacket(
       char* buffer, size_t length, bool owns_buffer,
-      QuicConnectionIdLength destination_connection_id_length,
-      QuicConnectionIdLength source_connection_id_length, bool includes_version,
+      uint8_t destination_connection_id_length,
+      uint8_t source_connection_id_length, bool includes_version,
       bool includes_diversification_nonce,
       QuicPacketNumberLength packet_number_length,
       quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
@@ -243,8 +243,8 @@
 
  private:
   char* buffer_;
-  const QuicConnectionIdLength destination_connection_id_length_;
-  const QuicConnectionIdLength source_connection_id_length_;
+  const uint8_t destination_connection_id_length_;
+  const uint8_t source_connection_id_length_;
   const bool includes_version_;
   const bool includes_diversification_nonce_;
   const QuicPacketNumberLength packet_number_length_;
diff --git a/quiche/quic/core/quic_stream_test.cc b/quiche/quic/core/quic_stream_test.cc
index deb7c98..1e77c5a 100644
--- a/quiche/quic/core/quic_stream_test.cc
+++ b/quiche/quic/core/quic_stream_test.cc
@@ -50,6 +50,8 @@
 const char kData1[] = "FooAndBar";
 const char kData2[] = "EepAndBaz";
 const QuicByteCount kDataLen = 9;
+const uint8_t kPacket0ByteConnectionId = 0;
+const uint8_t kPacket8ByteConnectionId = 8;
 
 class TestStream : public QuicStream {
  public:
@@ -343,8 +345,8 @@
 
   QuicByteCount length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
-              connection_->transport_version(), PACKET_8BYTE_CONNECTION_ID,
-              PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
+              connection_->transport_version(), kPacket8ByteConnectionId,
+              kPacket0ByteConnectionId, !kIncludeVersion,
               !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
               quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
               quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0u);
@@ -428,8 +430,8 @@
   EXPECT_FALSE(HasWriteBlockedStreams());
   QuicByteCount length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
-              connection_->transport_version(), PACKET_8BYTE_CONNECTION_ID,
-              PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
+              connection_->transport_version(), kPacket8ByteConnectionId,
+              kPacket0ByteConnectionId, !kIncludeVersion,
               !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
               quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
               quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0u);