diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index a9c6c4a..fa6fda7 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -10,6 +10,7 @@
 #include "net/third_party/quiche/src/quic/core/chlo_extractor.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
+#include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
 #include "net/third_party/quiche/src/quic/core/quic_time_wait_list_manager.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
@@ -303,8 +304,14 @@
       last_error_(QUIC_NO_ERROR),
       new_sessions_allowed_per_event_loop_(0u),
       accept_new_connections_(true),
-      allow_short_initial_connection_ids_(false) {
-  framer_.set_visitor(this);
+      allow_short_initial_connection_ids_(false),
+      last_version_label_(0),
+      expected_connection_id_length_(expected_connection_id_length),
+      should_update_expected_connection_id_length_(false),
+      no_framer_(GetQuicRestartFlag(quic_no_framer_object_in_dispatcher)) {
+  if (!no_framer_) {
+    framer_.set_visitor(this);
+  }
 }
 
 QuicDispatcher::~QuicDispatcher() {
@@ -326,21 +333,60 @@
   // GetClientAddress must be called after current_peer_address_ is set.
   current_client_address_ = GetClientAddress();
   current_packet_ = &packet;
-  // ProcessPacket will cause the packet to be dispatched in
-  // OnUnauthenticatedPublicHeader, or sent to the time wait list manager
-  // in OnUnauthenticatedHeader.
-  framer_.ProcessPacket(packet);
-  // TODO(rjshade): Return a status describing if/why a packet was dropped,
-  //                and log somehow.  Maybe expose as a varz.
-  // TODO(wub): Consider invalidate the current_* variables so processing of the
-  //            next packet does not use them incorrectly.
+  if (!no_framer_) {
+    // ProcessPacket will cause the packet to be dispatched in
+    // OnUnauthenticatedPublicHeader, or sent to the time wait list manager
+    // in OnUnauthenticatedHeader.
+    framer_.ProcessPacket(packet);
+    // TODO(rjshade): Return a status describing if/why a packet was dropped,
+    //                and log somehow.  Maybe expose as a varz.
+    return;
+  }
+  QUIC_RESTART_FLAG_COUNT(quic_no_framer_object_in_dispatcher);
+  QuicPacketHeader header;
+  uint8_t destination_connection_id_length;
+  string detailed_error;
+  const QuicErrorCode error = QuicFramer::ProcessPacketDispatcher(
+      packet, expected_connection_id_length_, &header.form,
+      &header.version_flag, &last_version_label_,
+      &destination_connection_id_length, &header.destination_connection_id,
+      &detailed_error);
+  if (error != QUIC_NO_ERROR) {
+    // Packet has framing error.
+    SetLastError(error);
+    QUIC_DLOG(ERROR) << detailed_error;
+    return;
+  }
+  header.version = ParseQuicVersionLabel(last_version_label_);
+  if (destination_connection_id_length != expected_connection_id_length_ &&
+      !should_update_expected_connection_id_length_ &&
+      !QuicUtils::VariableLengthConnectionIdAllowedForVersion(
+          header.version.transport_version)) {
+    SetLastError(QUIC_INVALID_PACKET_HEADER);
+    QUIC_DLOG(ERROR) << "Invalid Connection Id Length";
+    return;
+  }
+  if (should_update_expected_connection_id_length_) {
+    expected_connection_id_length_ = destination_connection_id_length;
+  }
+  // TODO(fayang): Instead of passing in QuicPacketHeader, pass format,
+  // version_flag, version and destination_connection_id. Combine
+  // OnUnauthenticatedPublicHeader and OnUnauthenticatedHeader to a single
+  // function when deprecating quic_no_framer_object_in_dispatcher.
+  if (!OnUnauthenticatedPublicHeader(header)) {
+    return;
+  }
+  OnUnauthenticatedHeader(header);
+  // TODO(wub): Consider invalidate the current_* variables so processing of
+  //            the next packet does not use them incorrectly.
 }
 
 QuicConnectionId QuicDispatcher::MaybeReplaceConnectionId(
     QuicConnectionId connection_id,
     ParsedQuicVersion version) {
   const uint8_t expected_connection_id_length =
-      framer_.GetExpectedConnectionIdLength();
+      no_framer_ ? expected_connection_id_length_
+                 : framer_.GetExpectedConnectionIdLength();
   if (connection_id.length() == expected_connection_id_length) {
     return connection_id;
   }
@@ -383,16 +429,18 @@
   // connection ID, the dispatcher picks a new one of its expected length.
   // Therefore we should never receive a connection ID that is smaller
   // than 64 bits and smaller than what we expect.
+  const uint8_t expected_connection_id_length =
+      no_framer_ ? expected_connection_id_length_
+                 : framer_.GetExpectedConnectionIdLength();
   if (connection_id.length() < kQuicMinimumInitialConnectionIdLength &&
-      connection_id.length() < framer_.GetExpectedConnectionIdLength() &&
+      connection_id.length() < expected_connection_id_length &&
       !allow_short_initial_connection_ids_) {
     DCHECK(header.version_flag);
     DCHECK(QuicUtils::VariableLengthConnectionIdAllowedForVersion(
         header.version.transport_version));
     QUIC_DLOG(INFO) << "Packet with short destination connection ID "
                     << connection_id << " expected "
-                    << static_cast<int>(
-                           framer_.GetExpectedConnectionIdLength());
+                    << static_cast<int>(expected_connection_id_length);
     ProcessUnauthenticatedHeaderFate(kFateTimeWait, connection_id, header.form,
                                      header.version_flag, header.version);
     return false;
@@ -449,12 +497,14 @@
   ParsedQuicVersion version = GetSupportedVersions().front();
   if (header.version_flag) {
     ParsedQuicVersion packet_version = header.version;
-    if (framer_.supported_versions() != GetSupportedVersions()) {
+    if (!no_framer_ && framer_.supported_versions() != GetSupportedVersions()) {
       // Reset framer's version if version flags change in flight.
       framer_.SetSupportedVersions(GetSupportedVersions());
     }
-    if (!framer_.IsSupportedVersion(packet_version)) {
-      if (ShouldCreateSessionForUnknownVersion(framer_.last_version_label())) {
+    if (!IsSupportedVersion(packet_version)) {
+      if (ShouldCreateSessionForUnknownVersion(
+              no_framer_ ? last_version_label_
+                         : framer_.last_version_label())) {
         return true;
       }
       if (!crypto_config()->validate_chlo_size() ||
@@ -470,8 +520,10 @@
     }
     version = packet_version;
   }
-  // Set the framer's version and continue processing.
-  framer_.set_version(version);
+  if (!no_framer_) {
+    // Set the framer's version and continue processing.
+    framer_.set_version(version);
+  }
 
   if (version.HasHeaderProtection()) {
     ProcessHeader(header);
@@ -573,6 +625,11 @@
     return kFateTimeWait;
   }
 
+  if (no_framer_) {
+    // Let the connection parse and validate packet number.
+    return kFateProcess;
+  }
+
   // initial packet number of 0 is always invalid.
   if (!framer_.version().HasHeaderProtection()) {
     if (!header.packet_number.IsInitialized()) {
@@ -797,7 +854,7 @@
   }
 
   // If the version is known and supported by framer, send a connection close.
-  if (framer_.IsSupportedVersion(version)) {
+  if (IsSupportedVersion(version)) {
     QUIC_DVLOG(1)
         << "Statelessly terminating " << connection_id
         << " based on an ietf-long packet, which has a supported version:"
@@ -852,6 +909,7 @@
 bool QuicDispatcher::OnProtocolVersionMismatch(
     ParsedQuicVersion /*received_version*/,
     PacketHeaderFormat /*form*/) {
+  DCHECK(!no_framer_);
   QUIC_BUG_IF(
       !time_wait_list_manager_->IsConnectionIdInTimeWait(
           current_connection_id_) &&
@@ -1146,7 +1204,7 @@
     EnqueuePacketResult rs = buffered_packets_.EnqueuePacket(
         current_connection_id_, form != GOOGLE_QUIC_PACKET, *current_packet_,
         current_self_address_, current_peer_address_,
-        /*is_chlo=*/true, current_alpn_, framer_.version());
+        /*is_chlo=*/true, current_alpn_, version);
     if (rs != EnqueuePacketResult::SUCCESS) {
       OnBufferPacketFailure(rs, current_connection_id_);
     }
@@ -1155,11 +1213,10 @@
 
   QuicConnectionId original_connection_id = current_connection_id_;
   current_connection_id_ =
-      MaybeReplaceConnectionId(current_connection_id_, framer_.version());
+      MaybeReplaceConnectionId(current_connection_id_, version);
   // Creates a new session and process all buffered packets for this connection.
-  QuicSession* session =
-      CreateQuicSession(current_connection_id_, current_peer_address_,
-                        current_alpn_, framer_.version());
+  QuicSession* session = CreateQuicSession(
+      current_connection_id_, current_peer_address_, current_alpn_, version);
   if (original_connection_id != current_connection_id_) {
     session->connection()->AddIncomingConnectionId(original_connection_id);
   }
@@ -1338,7 +1395,9 @@
   current_self_address_ = current_self_address;
   current_packet_ = current_packet.get();
   current_connection_id_ = rejector->connection_id();
-  framer_.set_version(first_version);
+  if (!no_framer_) {
+    framer_.set_version(first_version);
+  }
 
   // Stop buffering packets on this connection
   const auto num_erased =
@@ -1391,7 +1450,7 @@
       break;
 
     case StatelessRejector::REJECTED: {
-      QUIC_BUG_IF(first_version != framer_.version())
+      QUIC_BUG_IF(!no_framer_ && first_version != framer_.version())
           << "SREJ: Client's version: "
           << QuicVersionToString(first_version.transport_version)
           << " is different from current dispatcher framer's version: "
@@ -1438,7 +1497,22 @@
 }
 
 void QuicDispatcher::DisableFlagValidation() {
-  framer_.set_validate_flags(false);
+  if (!no_framer_) {
+    framer_.set_validate_flags(false);
+  }
+}
+
+bool QuicDispatcher::IsSupportedVersion(const ParsedQuicVersion version) {
+  if (!no_framer_) {
+    return framer_.IsSupportedVersion(version);
+  }
+  for (const ParsedQuicVersion& supported_version :
+       version_manager_->GetSupportedVersions()) {
+    if (version == supported_version) {
+      return true;
+    }
+  }
+  return false;
 }
 
 }  // namespace quic
diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index 0c951ed..6adf5f3 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -131,6 +131,9 @@
 
   // QuicFramerVisitorInterface implementation. Not expected to be called
   // outside of this class.
+  // TODO(fayang): Make QuicDispatcher no longer implement
+  // QuicFramerVisitorInterface when deprecating
+  // quic_no_framer_object_in_dispatcher.
   void OnPacket() override;
   // Called when the public header has been parsed. Returns false when just the
   // public header is enough to dispatch the packet; true if the framer needs to
@@ -361,8 +364,13 @@
   // 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);
+    if (!no_framer_) {
+      framer_.SetShouldUpdateExpectedConnectionIdLength(
+          should_update_expected_connection_id_length);
+      return;
+    }
+    should_update_expected_connection_id_length_ =
+        should_update_expected_connection_id_length;
   }
 
   // If true, the dispatcher will allow incoming initial packets that have
@@ -435,6 +443,9 @@
   QuicConnectionId MaybeReplaceConnectionId(QuicConnectionId connection_id,
                                             ParsedQuicVersion version);
 
+  // Returns true if |version| is a supported protocol version.
+  bool IsSupportedVersion(const ParsedQuicVersion version);
+
   void set_new_sessions_allowed_per_event_loop(
       int16_t new_sessions_allowed_per_event_loop) {
     new_sessions_allowed_per_event_loop_ = new_sessions_allowed_per_event_loop;
@@ -515,6 +526,28 @@
   // If false, the dispatcher follows the IETF spec and rejects packets with
   // invalid connection IDs lengths below 64 bits. If true they are allowed.
   bool allow_short_initial_connection_ids_;
+
+  // The last QUIC version label received. Used when no_framer_ is true.
+  // TODO(fayang): remove this member variable, instead, add an argument to
+  // OnUnauthenticatedPublicHeader when deprecating
+  // quic_no_framer_object_in_dispatcher.
+  QuicVersionLabel last_version_label_;
+
+  // IETF short headers contain a destination connection ID but do not
+  // encode its length. This variable contains the length we expect to read.
+  // This is also used to signal an error when a long header packet with
+  // different destination connection ID length is received when
+  // should_update_expected_connection_id_length_ is false and packet's version
+  // does not allow variable length connection ID. Used when no_framer_ is true.
+  uint8_t expected_connection_id_length_;
+
+  // If true, change expected_connection_id_length_ to be the received
+  // destination connection ID length of all IETF long headers. Used when
+  // no_framer_ is true.
+  bool should_update_expected_connection_id_length_;
+
+  // Latched value of quic_no_framer_object_in_dispatcher.
+  const bool no_framer_;
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 9c7cd1e..03b281b 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -815,7 +815,8 @@
 }
 
 TEST_F(QuicDispatcherTest, TooBigSeqNoPacketToTimeWaitListManager) {
-  if (CurrentSupportedVersions().front().HasHeaderProtection()) {
+  if (CurrentSupportedVersions().front().HasHeaderProtection() ||
+      GetQuicRestartFlag(quic_no_framer_object_in_dispatcher)) {
     // When header protection is in use, we don't put packets in the time wait
     // list manager based on packet number.
     return;
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 243529d..8d0dec2 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -449,6 +449,11 @@
                              "each time such a packet is dropped");
 }
 
+PacketHeaderFormat GetIetfPacketHeaderFormat(uint8_t type_byte) {
+  return type_byte & FLAGS_LONG_HEADER ? IETF_QUIC_LONG_HEADER_PACKET
+                                       : IETF_QUIC_SHORT_HEADER_PACKET;
+}
+
 }  // namespace
 
 QuicFramer::QuicFramer(const ParsedQuicVersionVector& supported_versions,
@@ -2511,8 +2516,7 @@
   }
   header->type_byte = type;
   // Determine whether this is a long or short header.
-  header->form = type & FLAGS_LONG_HEADER ? IETF_QUIC_LONG_HEADER_PACKET
-                                          : IETF_QUIC_SHORT_HEADER_PACKET;
+  header->form = GetIetfPacketHeaderFormat(type);
   if (header->form == IETF_QUIC_LONG_HEADER_PACKET) {
     // Version is always present in long headers.
     header->version_flag = true;
@@ -2610,13 +2614,19 @@
 }
 
 // static
-bool QuicFramer::ValidateIetfConnectionIdLength(
-    uint8_t connection_id_lengths_byte,
+bool QuicFramer::ProcessAndValidateIetfConnectionIdLength(
+    QuicDataReader* reader,
     ParsedQuicVersion version,
     bool should_update_expected_connection_id_length,
     uint8_t* expected_connection_id_length,
     uint8_t* destination_connection_id_length,
-    uint8_t* source_connection_id_length) {
+    uint8_t* source_connection_id_length,
+    std::string* detailed_error) {
+  uint8_t connection_id_lengths_byte;
+  if (!reader->ReadBytes(&connection_id_lengths_byte, 1)) {
+    *detailed_error = "Unable to read ConnectionId length.";
+    return false;
+  }
   uint8_t dcil =
       (connection_id_lengths_byte & kDestinationConnectionIdLengthMask) >> 4;
   if (dcil != 0) {
@@ -2642,6 +2652,7 @@
     // OnProtocolVersionMismatch call is moved to before this is run.
     QUIC_DVLOG(1) << "dcil: " << static_cast<uint32_t>(dcil)
                   << ", scil: " << static_cast<uint32_t>(scil);
+    *detailed_error = "Invalid ConnectionId length.";
     return false;
   }
   *destination_connection_id_length = dcil;
@@ -2664,18 +2675,11 @@
           ? expected_connection_id_length_
           : 0;
   if (header->form == IETF_QUIC_LONG_HEADER_PACKET) {
-    // Read and validate connection ID length.
-    uint8_t connection_id_lengths_byte;
-    if (!reader->ReadBytes(&connection_id_lengths_byte, 1)) {
-      set_detailed_error("Unable to read ConnectionId length.");
-      return false;
-    }
-    if (!ValidateIetfConnectionIdLength(
-            connection_id_lengths_byte, header->version,
+    if (!ProcessAndValidateIetfConnectionIdLength(
+            reader, header->version,
             should_update_expected_connection_id_length_,
             &expected_connection_id_length_, &destination_connection_id_length,
-            &source_connection_id_length)) {
-      set_detailed_error("Invalid ConnectionId length.");
+            &source_connection_id_length, &detailed_error_)) {
       return false;
     }
   }
@@ -6054,5 +6058,75 @@
   supports_multiple_packet_number_spaces_ = true;
 }
 
+// static
+QuicErrorCode QuicFramer::ProcessPacketDispatcher(
+    const QuicEncryptedPacket& packet,
+    uint8_t expected_connection_id_length,
+    PacketHeaderFormat* format,
+    bool* version_flag,
+    QuicVersionLabel* version_label,
+    uint8_t* destination_connection_id_length,
+    QuicConnectionId* destination_connection_id,
+    std::string* detailed_error) {
+  QuicDataReader reader(packet.data(), packet.length());
+
+  uint8_t first_byte;
+  if (!reader.ReadBytes(&first_byte, 1)) {
+    *detailed_error = "Unable to read first byte.";
+    return QUIC_INVALID_PACKET_HEADER;
+  }
+  if (!QuicUtils::IsIetfPacketHeader(first_byte)) {
+    *format = GOOGLE_QUIC_PACKET;
+    *version_flag = (first_byte & PACKET_PUBLIC_FLAGS_VERSION) != 0;
+    *destination_connection_id_length =
+        first_byte & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
+    if (*destination_connection_id_length == 0 ||
+        !reader.ReadConnectionId(destination_connection_id,
+                                 *destination_connection_id_length)) {
+      *detailed_error = "Unable to read ConnectionId.";
+      return QUIC_INVALID_PACKET_HEADER;
+    }
+    if (*version_flag && !ProcessVersionLabel(&reader, version_label)) {
+      *detailed_error = "Unable to read protocol version.";
+      return QUIC_INVALID_PACKET_HEADER;
+    }
+    return QUIC_NO_ERROR;
+  }
+
+  *format = GetIetfPacketHeaderFormat(first_byte);
+  QUIC_DVLOG(1) << "Dispatcher: Processing IETF QUIC packet, format: "
+                << *format;
+  *version_flag = *format == IETF_QUIC_LONG_HEADER_PACKET;
+  if (*format == IETF_QUIC_LONG_HEADER_PACKET) {
+    if (!ProcessVersionLabel(&reader, version_label)) {
+      *detailed_error = "Unable to read protocol version.";
+      return QUIC_INVALID_PACKET_HEADER;
+    }
+    // Set should_update_expected_connection_id_length to true to bypass
+    // connection ID lengths validation.
+    uint8_t unused_source_connection_id_length = 0;
+    uint8_t unused_expected_connection_id_length = 0;
+    if (!ProcessAndValidateIetfConnectionIdLength(
+            &reader, ParseQuicVersionLabel(*version_label),
+            /*should_update_expected_connection_id_length=*/true,
+            &unused_expected_connection_id_length,
+            destination_connection_id_length,
+            &unused_source_connection_id_length, detailed_error)) {
+      return QUIC_INVALID_PACKET_HEADER;
+    }
+  } else {
+    // For short header packets, expected_connection_id_length is used to
+    // determine the destination_connection_id_length.
+    *destination_connection_id_length = expected_connection_id_length;
+  }
+  // Read destination connection ID.
+  if (!reader.ReadConnectionId(destination_connection_id,
+                               *destination_connection_id_length)) {
+    *detailed_error = "Unable to read Destination ConnectionId.";
+    return QUIC_INVALID_PACKET_HEADER;
+  }
+  return QUIC_NO_ERROR;
+}
+
 #undef ENDPOINT  // undef for jumbo builds
 }  // namespace quic
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index e2d7b4d..59e300c 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -373,6 +373,21 @@
       uint64_t retry_token_length,
       QuicVariableLengthIntegerLength length_length);
 
+  // Lightweight parsing of |packet| and populates |format|, |version_flag|,
+  // |version_label|, |destination_connection_id_length|,
+  // |destination_connection_id| and |detailed_error|. Please note,
+  // |expected_connection_id_length| is only used to determine IETF short header
+  // packet's destination connection ID length.
+  static QuicErrorCode ProcessPacketDispatcher(
+      const QuicEncryptedPacket& packet,
+      uint8_t expected_connection_id_length,
+      PacketHeaderFormat* format,
+      bool* version_flag,
+      QuicVersionLabel* version_label,
+      uint8_t* destination_connection_id_length,
+      QuicConnectionId* destination_connection_id,
+      std::string* detailed_error);
+
   // Serializes a packet containing |frames| into |buffer|.
   // Returns the length of the packet, which must not be longer than
   // |packet_length|.  Returns 0 if it fails to serialize.
@@ -665,13 +680,14 @@
 
   // Validates and updates |destination_connection_id_length| and
   // |source_connection_id_length|.
-  static bool ValidateIetfConnectionIdLength(
-      uint8_t connection_id_lengths_byte,
+  static bool ProcessAndValidateIetfConnectionIdLength(
+      QuicDataReader* reader,
       ParsedQuicVersion version,
       bool should_update_expected_connection_id_length,
       uint8_t* expected_connection_id_length,
       uint8_t* destination_connection_id_length,
-      uint8_t* source_connection_id_length);
+      uint8_t* source_connection_id_length,
+      std::string* detailed_error);
 
   bool ProcessIetfHeaderTypeByte(QuicDataReader* reader,
                                  QuicPacketHeader* header);
@@ -921,6 +937,8 @@
   // Updated by WritePacketHeader.
   QuicConnectionId last_serialized_connection_id_;
   // The last QUIC version label received.
+  // TODO(fayang): Remove this when deprecating
+  // quic_no_framer_object_in_dispatcher.
   QuicVersionLabel last_version_label_;
   // Version of the protocol being used.
   ParsedQuicVersion version_;
@@ -975,10 +993,14 @@
   // 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.
+  // TODO(fayang): Remove this when deprecating
+  // quic_no_framer_object_in_dispatcher.
   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.
+  // TODO(fayang): Remove this when deprecating
+  // quic_no_framer_object_in_dispatcher.
   bool should_update_expected_connection_id_length_;
 
   // Indicates whether this framer supports multiple packet number spaces.
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 4af5b3a..96f335c 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -913,6 +913,22 @@
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   CheckFramingBoundaries(fragments, QUIC_INVALID_PACKET_HEADER);
+
+  PacketHeaderFormat format;
+  bool version_flag;
+  uint8_t destination_connection_id_length;
+  QuicConnectionId destination_connection_id;
+  QuicVersionLabel version_label;
+  std::string detailed_error;
+  EXPECT_EQ(QUIC_NO_ERROR, QuicFramer::ProcessPacketDispatcher(
+                               *encrypted, kQuicDefaultConnectionIdLength,
+                               &format, &version_flag, &version_label,
+                               &destination_connection_id_length,
+                               &destination_connection_id, &detailed_error));
+  EXPECT_EQ(GOOGLE_QUIC_PACKET, format);
+  EXPECT_FALSE(version_flag);
+  EXPECT_EQ(kQuicDefaultConnectionIdLength, destination_connection_id_length);
+  EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
 }
 
 TEST_P(QuicFramerTest, LongPacketHeader) {
@@ -975,6 +991,22 @@
   CheckFramingBoundaries(
       framer_.transport_version() > QUIC_VERSION_44 ? packet46 : packet44,
       QUIC_INVALID_PACKET_HEADER);
+
+  PacketHeaderFormat format;
+  bool version_flag;
+  uint8_t destination_connection_id_length;
+  QuicConnectionId destination_connection_id;
+  QuicVersionLabel version_label;
+  std::string detailed_error;
+  EXPECT_EQ(QUIC_NO_ERROR, QuicFramer::ProcessPacketDispatcher(
+                               *encrypted, kQuicDefaultConnectionIdLength,
+                               &format, &version_flag, &version_label,
+                               &destination_connection_id_length,
+                               &destination_connection_id, &detailed_error));
+  EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
+  EXPECT_TRUE(version_flag);
+  EXPECT_EQ(kQuicDefaultConnectionIdLength, destination_connection_id_length);
+  EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith0ByteConnectionId) {
@@ -13251,6 +13283,34 @@
             FramerTestConnectionIdNineBytes());
   EXPECT_EQ(visitor_.header_.get()->packet_number,
             QuicPacketNumber(UINT64_C(0x13374233)));
+
+  PacketHeaderFormat format;
+  bool version_flag;
+  uint8_t destination_connection_id_length;
+  QuicConnectionId destination_connection_id;
+  QuicVersionLabel version_label;
+  std::string detailed_error;
+  EXPECT_EQ(QUIC_NO_ERROR,
+            QuicFramer::ProcessPacketDispatcher(
+                QuicEncryptedPacket(AsChars(long_header_packet),
+                                    QUIC_ARRAYSIZE(long_header_packet)),
+                kQuicDefaultConnectionIdLength, &format, &version_flag,
+                &version_label, &destination_connection_id_length,
+                &destination_connection_id, &detailed_error));
+  EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
+  EXPECT_TRUE(version_flag);
+  EXPECT_EQ(9, destination_connection_id_length);
+  EXPECT_EQ(FramerTestConnectionIdNineBytes(), destination_connection_id);
+
+  EXPECT_EQ(QUIC_NO_ERROR,
+            QuicFramer::ProcessPacketDispatcher(
+                short_header_encrypted, 9, &format, &version_flag,
+                &version_label, &destination_connection_id_length,
+                &destination_connection_id, &detailed_error));
+  EXPECT_EQ(IETF_QUIC_SHORT_HEADER_PACKET, format);
+  EXPECT_FALSE(version_flag);
+  EXPECT_EQ(9, destination_connection_id_length);
+  EXPECT_EQ(FramerTestConnectionIdNineBytes(), destination_connection_id);
 }
 
 TEST_P(QuicFramerTest, MultiplePacketNumberSpaces) {