diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index 77d4952..aadd06b 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -349,6 +349,14 @@
   // Skip validating that the public flags are set to legal values.
   void DisableFlagValidation();
 
+  // If true, our framer will change its expected connection ID length
+  // to the received destination connection ID length of all IETF long headers.
+  void SetShouldUpdateExpectedConnectionIdLength(
+      bool should_update_expected_connection_id_length) {
+    framer_.SetShouldUpdateExpectedConnectionIdLength(
+        should_update_expected_connection_id_length);
+  }
+
  private:
   friend class test::QuicDispatcherPeer;
   friend class StatelessRejectorProcessDoneCallback;
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 22d0ecf..32d50c5 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -473,7 +473,8 @@
       data_producer_(nullptr),
       infer_packet_header_type_from_version_(perspective ==
                                              Perspective::IS_CLIENT),
-      expected_connection_id_length_(expected_connection_id_length) {
+      expected_connection_id_length_(expected_connection_id_length),
+      should_update_expected_connection_id_length_(false) {
   DCHECK(!supported_versions.empty());
   version_ = supported_versions_[0];
   decrypter_ = QuicMakeUnique<NullDecrypter>(perspective);
@@ -2565,12 +2566,20 @@
     if (dcil != 0) {
       dcil += kConnectionIdLengthAdjustment;
     }
+    if (should_update_expected_connection_id_length_ &&
+        expected_connection_id_length_ != dcil) {
+      QUIC_DVLOG(1) << ENDPOINT << "Updating expected_connection_id_length: "
+                    << static_cast<int>(expected_connection_id_length_)
+                    << " -> " << static_cast<int>(dcil);
+      expected_connection_id_length_ = dcil;
+    }
     uint8_t scil = connection_id_lengths_byte & kSourceConnectionIdLengthMask;
     if (scil != 0) {
       scil += kConnectionIdLengthAdjustment;
     }
-    if (dcil != destination_connection_id_length ||
-        scil != source_connection_id_length) {
+    if ((dcil != destination_connection_id_length ||
+         scil != source_connection_id_length) &&
+        !should_update_expected_connection_id_length_) {
       QUIC_DVLOG(1) << "dcil: " << static_cast<uint32_t>(dcil)
                     << ", scil: " << static_cast<uint32_t>(scil);
       set_detailed_error("Invalid ConnectionId length.");
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index d6916f6..c18e9db 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -565,6 +565,14 @@
     return first_sending_packet_number_;
   }
 
+  // If true, QuicFramer will change its expected connection ID length
+  // to the received destination connection ID length of all IETF long headers.
+  void SetShouldUpdateExpectedConnectionIdLength(
+      bool should_update_expected_connection_id_length) {
+    should_update_expected_connection_id_length_ =
+        should_update_expected_connection_id_length;
+  }
+
  private:
   friend class test::QuicFramerPeer;
 
@@ -921,7 +929,11 @@
   // encode its length. This variable contains the length we expect to read.
   // This is also used to validate the long header connection ID lengths in
   // older versions of QUIC.
-  const uint8_t expected_connection_id_length_;
+  uint8_t expected_connection_id_length_;
+
+  // When this is true, QuicFramer will change expected_connection_id_length_
+  // to the received destination connection ID length of all IETF long headers.
+  bool should_update_expected_connection_id_length_;
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 527307a..c848c0a 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -12925,6 +12925,91 @@
   CheckFramingBoundaries(packet, QUIC_INVALID_PACKET_HEADER);
 }
 
+TEST_P(QuicFramerTest, UpdateExpectedConnectionIdLength) {
+  if (framer_.transport_version() < QUIC_VERSION_46) {
+    return;
+  }
+  char connection_id_bytes[9] = {0xFE, 0xDC, 0xBA, 0x98, 0x76,
+                                 0x54, 0x32, 0x10, 0x42};
+  QuicConnectionId connection_id(connection_id_bytes,
+                                 sizeof(connection_id_bytes));
+  framer_.SetShouldUpdateExpectedConnectionIdLength(true);
+
+  // clang-format off
+  unsigned char long_header_packet[] = {
+      // public flags (long header with packet type ZERO_RTT_PROTECTED and
+      // 4-byte packet number)
+      0xD3,
+      // version
+      QUIC_VERSION_BYTES,
+      // destination connection ID length
+      0x60,
+      // destination connection ID
+      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0x42,
+      // packet number
+      0x12, 0x34, 0x56, 0x78,
+      // padding frame
+      0x00,
+  };
+  unsigned char long_header_packet99[] = {
+      // public flags (long header with packet type ZERO_RTT_PROTECTED and
+      // 4-byte packet number)
+      0xD3,
+      // version
+      QUIC_VERSION_BYTES,
+      // destination connection ID length
+      0x60,
+      // destination connection ID
+      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0x42,
+      // long header packet length
+      0x05,
+      // packet number
+      0x12, 0x34, 0x56, 0x78,
+      // padding frame
+      0x00,
+  };
+  // clang-format on
+
+  if (!QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
+    EXPECT_TRUE(framer_.ProcessPacket(
+        QuicEncryptedPacket(AsChars(long_header_packet),
+                            QUIC_ARRAYSIZE(long_header_packet), false)));
+  } else {
+    EXPECT_TRUE(framer_.ProcessPacket(
+        QuicEncryptedPacket(AsChars(long_header_packet99),
+                            QUIC_ARRAYSIZE(long_header_packet99), false)));
+  }
+
+  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  ASSERT_TRUE(visitor_.header_.get());
+  EXPECT_EQ(visitor_.header_.get()->destination_connection_id, connection_id);
+  EXPECT_EQ(visitor_.header_.get()->packet_number,
+            QuicPacketNumber(UINT64_C(0x12345678)));
+
+  // clang-format off
+  unsigned char short_header_packet[] = {
+    // type (short header, 4 byte packet number)
+    0x43,
+    // connection_id
+    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0x42,
+    // packet number
+    0x13, 0x37, 0x42, 0x33,
+    // padding frame
+    0x00,
+  };
+  // clang-format on
+
+  QuicEncryptedPacket short_header_encrypted(
+      AsChars(short_header_packet), QUIC_ARRAYSIZE(short_header_packet), false);
+  EXPECT_TRUE(framer_.ProcessPacket(short_header_encrypted));
+
+  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  ASSERT_TRUE(visitor_.header_.get());
+  EXPECT_EQ(visitor_.header_.get()->destination_connection_id, connection_id);
+  EXPECT_EQ(visitor_.header_.get()->packet_number,
+            QuicPacketNumber(UINT64_C(0x13374233)));
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quic/quartc/quartc_dispatcher.cc b/quic/quartc/quartc_dispatcher.cc
index 8070203..4c35c54 100644
--- a/quic/quartc/quartc_dispatcher.cc
+++ b/quic/quartc/quartc_dispatcher.cc
@@ -21,18 +21,23 @@
     std::unique_ptr<QuicAlarmFactory> alarm_factory,
     std::unique_ptr<QuartcPacketWriter> packet_writer,
     Delegate* delegate)
-    : QuicDispatcher(config.get(),
-                     crypto_config.get(),
-                     version_manager,
-                     std::move(helper),
-                     std::move(session_helper),
-                     std::move(alarm_factory),
-                     kQuicDefaultConnectionIdLength),
+    : QuicDispatcher(
+          config.get(),
+          crypto_config.get(),
+          version_manager,
+          std::move(helper),
+          std::move(session_helper),
+          std::move(alarm_factory),
+          QuicUtils::CreateZeroConnectionId(
+              version_manager->GetSupportedVersions()[0].transport_version)
+              .length()),
       owned_quic_config_(std::move(config)),
       owned_crypto_config_(std::move(crypto_config)),
       crypto_config_(crypto_config_serialized),
       delegate_(delegate),
       packet_writer_(packet_writer.get()) {
+  // Allow incoming packets to set our expected connection ID length.
+  SetShouldUpdateExpectedConnectionIdLength(true);
   // QuicDispatcher takes ownership of the writer.
   QuicDispatcher::InitializeWithWriter(packet_writer.release());
   // NB: This must happen *after* InitializeWithWriter.  It can call us back
@@ -50,6 +55,8 @@
     const QuicSocketAddress& client_address,
     QuicStringPiece alpn,
     const ParsedQuicVersion& version) {
+  // Make our expected connection ID non-mutable since we have a connection.
+  SetShouldUpdateExpectedConnectionIdLength(false);
   std::unique_ptr<QuicConnection> connection = CreateQuicConnection(
       connection_id, client_address, helper(), alarm_factory(), writer(),
       Perspective::IS_SERVER, ParsedQuicVersionVector{version});
diff --git a/quic/quartc/quartc_factory.cc b/quic/quartc/quartc_factory.cc
index 803122a..8efa544 100644
--- a/quic/quartc/quartc_factory.cc
+++ b/quic/quartc/quartc_factory.cc
@@ -197,13 +197,12 @@
     QuartcPacketWriter* packet_writer) {
   // |dummy_id| and |dummy_address| are used because Quartc network layer will
   // not use these two.
-    char connection_id_bytes[sizeof(uint64_t)] = {};
-    QuicConnectionId dummy_id = QuicConnectionId(
-        static_cast<char*>(connection_id_bytes), sizeof(connection_id_bytes));
-    QuicSocketAddress dummy_address(QuicIpAddress::Any4(), /*port=*/0);
-    return quic::CreateQuicConnection(
-        dummy_id, dummy_address, connection_helper_.get(), alarm_factory_,
-        packet_writer, perspective, supported_versions);
+  QuicConnectionId dummy_id = QuicUtils::CreateZeroConnectionId(
+      supported_versions[0].transport_version);
+  QuicSocketAddress dummy_address(QuicIpAddress::Any4(), /*port=*/0);
+  return quic::CreateQuicConnection(
+      dummy_id, dummy_address, connection_helper_.get(), alarm_factory_,
+      packet_writer, perspective, supported_versions);
 }
 
 std::unique_ptr<QuicConnection> CreateQuicConnection(