diff --git a/quic/core/http/http_decoder.cc b/quic/core/http/http_decoder.cc
index d424c04..550aa6f 100644
--- a/quic/core/http/http_decoder.cc
+++ b/quic/core/http/http_decoder.cc
@@ -133,24 +133,23 @@
   // Calling the following visitor methods does not require parsing of any
   // frame payload.
   bool continue_processing = true;
-  auto frame_meta = Http3FrameLengths(
-      current_length_field_length_ + current_type_field_length_,
-      current_frame_length_);
+  const QuicByteCount header_length =
+      current_length_field_length_ + current_type_field_length_;
 
   switch (current_frame_type_) {
     case static_cast<uint64_t>(HttpFrameType::DATA):
-      continue_processing = visitor_->OnDataFrameStart(frame_meta);
+      continue_processing = visitor_->OnDataFrameStart(header_length);
       break;
     case static_cast<uint64_t>(HttpFrameType::HEADERS):
-      continue_processing = visitor_->OnHeadersFrameStart(frame_meta);
+      continue_processing = visitor_->OnHeadersFrameStart(header_length);
       break;
     case static_cast<uint64_t>(HttpFrameType::PRIORITY):
-      continue_processing = visitor_->OnPriorityFrameStart(frame_meta);
+      continue_processing = visitor_->OnPriorityFrameStart(header_length);
       break;
     case static_cast<uint64_t>(HttpFrameType::CANCEL_PUSH):
       break;
     case static_cast<uint64_t>(HttpFrameType::SETTINGS):
-      continue_processing = visitor_->OnSettingsFrameStart(frame_meta);
+      continue_processing = visitor_->OnSettingsFrameStart(header_length);
       break;
     case static_cast<uint64_t>(HttpFrameType::PUSH_PROMISE):
       break;
@@ -162,7 +161,7 @@
       break;
     default:
       continue_processing =
-          visitor_->OnUnknownFrameStart(current_frame_type_, frame_meta);
+          visitor_->OnUnknownFrameStart(current_frame_type_, header_length);
       break;
   }
 
@@ -228,9 +227,7 @@
         remaining_frame_length_ -= bytes_remaining - reader->BytesRemaining();
         if (!visitor_->OnPushPromiseFrameStart(
                 push_id,
-                Http3FrameLengths(
                     current_length_field_length_ + current_type_field_length_,
-                    current_frame_length_),
                 push_id_length)) {
           continue_processing = false;
           break;
diff --git a/quic/core/http/http_decoder.h b/quic/core/http/http_decoder.h
index 723251b..21561b9 100644
--- a/quic/core/http/http_decoder.h
+++ b/quic/core/http/http_decoder.h
@@ -20,22 +20,6 @@
 
 class QuicDataReader;
 
-// Struct that stores meta data of an HTTP/3 frame.
-// |header_length| is frame header length in bytes.
-// |payload_length| is frame payload length in bytes.
-struct QUIC_EXPORT_PRIVATE Http3FrameLengths {
-  Http3FrameLengths(QuicByteCount header, QuicByteCount payload)
-      : header_length(header), payload_length(payload) {}
-
-  bool operator==(const Http3FrameLengths& other) const {
-    return (header_length == other.header_length) &&
-           (payload_length == other.payload_length);
-  }
-
-  QuicByteCount header_length;
-  QuicByteCount payload_length;
-};
-
 // A class for decoding the HTTP frames that are exchanged in an HTTP over QUIC
 // session.
 class QUIC_EXPORT_PRIVATE HttpDecoder {
@@ -55,7 +39,7 @@
 
     // Called when a PRIORITY frame has been received.
     // |frame_length| contains PRIORITY frame length and payload length.
-    virtual bool OnPriorityFrameStart(Http3FrameLengths frame_length) = 0;
+    virtual bool OnPriorityFrameStart(QuicByteCount header_length) = 0;
 
     // Called when a PRIORITY frame has been successfully parsed.
     virtual bool OnPriorityFrame(const PriorityFrame& frame) = 0;
@@ -70,7 +54,7 @@
     virtual bool OnGoAwayFrame(const GoAwayFrame& frame) = 0;
 
     // Called when a SETTINGS frame has been received.
-    virtual bool OnSettingsFrameStart(Http3FrameLengths frame_length) = 0;
+    virtual bool OnSettingsFrameStart(QuicByteCount header_length) = 0;
 
     // Called when a SETTINGS frame has been successfully parsed.
     virtual bool OnSettingsFrame(const SettingsFrame& frame) = 0;
@@ -80,7 +64,7 @@
 
     // Called when a DATA frame has been received.
     // |frame_length| contains DATA frame length and payload length.
-    virtual bool OnDataFrameStart(Http3FrameLengths frame_length) = 0;
+    virtual bool OnDataFrameStart(QuicByteCount header_length) = 0;
     // Called when part of the payload of a DATA frame has been read.  May be
     // called multiple times for a single frame.  |payload| is guaranteed to be
     // non-empty.
@@ -90,7 +74,7 @@
 
     // Called when a HEADERS frame has been received.
     // |frame_length| contains HEADERS frame length and payload length.
-    virtual bool OnHeadersFrameStart(Http3FrameLengths frame_length) = 0;
+    virtual bool OnHeadersFrameStart(QuicByteCount header_length) = 0;
     // Called when part of the payload of a HEADERS frame has been read.  May be
     // called multiple times for a single frame.  |payload| is guaranteed to be
     // non-empty.
@@ -101,7 +85,7 @@
 
     // Called when a PUSH_PROMISE frame has been received for |push_id|.
     virtual bool OnPushPromiseFrameStart(PushId push_id,
-                                         Http3FrameLengths frame_length,
+                                         QuicByteCount header_length,
                                          QuicByteCount push_id_length) = 0;
     // Called when part of the payload of a PUSH_PROMISE frame has been read.
     // May be called multiple times for a single frame.  |payload| is guaranteed
@@ -114,7 +98,7 @@
     // Frame type might be reserved, Visitor must make sure to ignore.
     // |frame_length| contains frame length and payload length.
     virtual bool OnUnknownFrameStart(uint64_t frame_type,
-                                     Http3FrameLengths frame_length) = 0;
+                                     QuicByteCount header_length) = 0;
     // Called when part of the payload of the unknown frame has been read.  May
     // be called multiple times for a single frame.  |payload| is guaranteed to
     // be non-empty.
diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc
index be47ee4..476c2c6 100644
--- a/quic/core/http/http_decoder_test.cc
+++ b/quic/core/http/http_decoder_test.cc
@@ -34,31 +34,31 @@
   // Called if an error is detected.
   MOCK_METHOD1(OnError, void(HttpDecoder* decoder));
 
-  MOCK_METHOD1(OnPriorityFrameStart, bool(Http3FrameLengths frame_lengths));
+  MOCK_METHOD1(OnPriorityFrameStart, bool(QuicByteCount header_length));
   MOCK_METHOD1(OnPriorityFrame, bool(const PriorityFrame& frame));
   MOCK_METHOD1(OnCancelPushFrame, bool(const CancelPushFrame& frame));
   MOCK_METHOD1(OnMaxPushIdFrame, bool(const MaxPushIdFrame& frame));
   MOCK_METHOD1(OnGoAwayFrame, bool(const GoAwayFrame& frame));
-  MOCK_METHOD1(OnSettingsFrameStart, bool(Http3FrameLengths frame_lengths));
+  MOCK_METHOD1(OnSettingsFrameStart, bool(QuicByteCount header_length));
   MOCK_METHOD1(OnSettingsFrame, bool(const SettingsFrame& frame));
   MOCK_METHOD1(OnDuplicatePushFrame, bool(const DuplicatePushFrame& frame));
 
-  MOCK_METHOD1(OnDataFrameStart, bool(Http3FrameLengths frame_lengths));
+  MOCK_METHOD1(OnDataFrameStart, bool(QuicByteCount header_length));
   MOCK_METHOD1(OnDataFramePayload, bool(QuicStringPiece payload));
   MOCK_METHOD0(OnDataFrameEnd, bool());
 
-  MOCK_METHOD1(OnHeadersFrameStart, bool(Http3FrameLengths frame_lengths));
+  MOCK_METHOD1(OnHeadersFrameStart, bool(QuicByteCount header_length));
   MOCK_METHOD1(OnHeadersFramePayload, bool(QuicStringPiece payload));
   MOCK_METHOD0(OnHeadersFrameEnd, bool());
 
   MOCK_METHOD3(OnPushPromiseFrameStart,
                bool(PushId push_id,
-                    Http3FrameLengths frame_lengths,
+                    QuicByteCount header_length,
                     QuicByteCount push_id_length));
   MOCK_METHOD1(OnPushPromiseFramePayload, bool(QuicStringPiece payload));
   MOCK_METHOD0(OnPushPromiseFrameEnd, bool());
 
-  MOCK_METHOD2(OnUnknownFrameStart, bool(uint64_t, Http3FrameLengths));
+  MOCK_METHOD2(OnUnknownFrameStart, bool(uint64_t, QuicByteCount));
   MOCK_METHOD1(OnUnknownFramePayload, bool(QuicStringPiece));
   MOCK_METHOD0(OnUnknownFrameEnd, bool());
 };
@@ -158,9 +158,7 @@
         writer.WriteStringPiece(data);
       }
 
-      EXPECT_CALL(visitor_, OnUnknownFrameStart(
-                                frame_type, Http3FrameLengths(header_length,
-                                                              payload_length)));
+      EXPECT_CALL(visitor_, OnUnknownFrameStart(frame_type, header_length));
       if (payload_length > 0) {
         EXPECT_CALL(visitor_, OnUnknownFramePayload(Eq(data)));
       }
@@ -211,7 +209,7 @@
       "Headers";  // Header Block
 
   // Visitor pauses processing.
-  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, Http3FrameLengths(2, 8), 1))
+  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, 2, 1))
       .WillOnce(Return(false));
   QuicStringPiece remaining_input(input);
   QuicByteCount processed_bytes =
@@ -230,7 +228,7 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the full frame.
-  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, Http3FrameLengths(2, 8), 1));
+  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, 2, 1));
   EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("Headers")));
   EXPECT_CALL(visitor_, OnPushPromiseFrameEnd());
   EXPECT_EQ(input.size(), ProcessInput(input));
@@ -238,7 +236,7 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the frame incrementally.
-  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, Http3FrameLengths(2, 8), 1));
+  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, 2, 1));
   EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("H")));
   EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("e")));
   EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("a")));
@@ -325,8 +323,7 @@
   frame.weight = 0xFF;
 
   // Visitor pauses processing.
-  EXPECT_CALL(visitor_, OnPriorityFrameStart(Http3FrameLengths(2, 4)))
-      .WillOnce(Return(false));
+  EXPECT_CALL(visitor_, OnPriorityFrameStart(2)).WillOnce(Return(false));
   QuicStringPiece remaining_input(input);
   QuicByteCount processed_bytes =
       ProcessInputWithGarbageAppended(remaining_input);
@@ -340,14 +337,14 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the full frame.
-  EXPECT_CALL(visitor_, OnPriorityFrameStart(Http3FrameLengths(2, 4)));
+  EXPECT_CALL(visitor_, OnPriorityFrameStart(2));
   EXPECT_CALL(visitor_, OnPriorityFrame(frame));
   EXPECT_EQ(input.size(), ProcessInput(input));
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the frame incrementally.
-  EXPECT_CALL(visitor_, OnPriorityFrameStart(Http3FrameLengths(2, 4)));
+  EXPECT_CALL(visitor_, OnPriorityFrameStart(2));
   EXPECT_CALL(visitor_, OnPriorityFrame(frame));
   ProcessInputCharByChar(input);
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
@@ -364,7 +361,7 @@
   frame2.exclusive = true;
   frame2.weight = 0xFF;
 
-  EXPECT_CALL(visitor_, OnPriorityFrameStart(Http3FrameLengths(2, 2)));
+  EXPECT_CALL(visitor_, OnPriorityFrameStart(2));
   EXPECT_CALL(visitor_, OnPriorityFrame(frame2));
   EXPECT_EQ(input2.size(), ProcessInput(input2));
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
@@ -406,8 +403,7 @@
     input.append(test_data.payload, test_data.payload_length);
 
     HttpDecoder decoder(&visitor_);
-    EXPECT_CALL(visitor_, OnPriorityFrameStart(Http3FrameLengths(
-                              header_length, test_data.payload_length)));
+    EXPECT_CALL(visitor_, OnPriorityFrameStart(header_length));
 
     QuicByteCount processed_bytes =
         decoder.ProcessInput(input.data(), input.size());
@@ -437,8 +433,7 @@
 
   // Visitor pauses processing.
   QuicStringPiece remaining_input(input);
-  EXPECT_CALL(visitor_, OnSettingsFrameStart(Http3FrameLengths(2, 7)))
-      .WillOnce(Return(false));
+  EXPECT_CALL(visitor_, OnSettingsFrameStart(2)).WillOnce(Return(false));
   QuicByteCount processed_bytes =
       ProcessInputWithGarbageAppended(remaining_input);
   EXPECT_EQ(2u, processed_bytes);
@@ -451,14 +446,14 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the full frame.
-  EXPECT_CALL(visitor_, OnSettingsFrameStart(Http3FrameLengths(2, 7)));
+  EXPECT_CALL(visitor_, OnSettingsFrameStart(2));
   EXPECT_CALL(visitor_, OnSettingsFrame(frame));
   EXPECT_EQ(input.size(), ProcessInput(input));
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the frame incrementally.
-  EXPECT_CALL(visitor_, OnSettingsFrameStart(Http3FrameLengths(2, 7)));
+  EXPECT_CALL(visitor_, OnSettingsFrameStart(2));
   EXPECT_CALL(visitor_, OnSettingsFrame(frame));
   ProcessInputCharByChar(input);
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
@@ -474,8 +469,7 @@
       7);
 
   // Visitor pauses processing.
-  EXPECT_CALL(visitor_, OnDataFrameStart(Http3FrameLengths(2, 5)))
-      .WillOnce(Return(false));
+  EXPECT_CALL(visitor_, OnDataFrameStart(2)).WillOnce(Return(false));
   QuicStringPiece remaining_input(input);
   QuicByteCount processed_bytes =
       ProcessInputWithGarbageAppended(remaining_input);
@@ -493,7 +487,7 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the full frame.
-  EXPECT_CALL(visitor_, OnDataFrameStart(Http3FrameLengths(2, 5)));
+  EXPECT_CALL(visitor_, OnDataFrameStart(2));
   EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("Data!")));
   EXPECT_CALL(visitor_, OnDataFrameEnd());
   EXPECT_EQ(input.size(), ProcessInput(input));
@@ -501,7 +495,7 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the frame incrementally.
-  EXPECT_CALL(visitor_, OnDataFrameStart(Http3FrameLengths(2, 5)));
+  EXPECT_CALL(visitor_, OnDataFrameStart(2));
   EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("D")));
   EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("a")));
   EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("t")));
@@ -528,7 +522,7 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Send the rest of the header.
-  EXPECT_CALL(visitor_, OnDataFrameStart(Http3FrameLengths(3, 2048)));
+  EXPECT_CALL(visitor_, OnDataFrameStart(3));
   EXPECT_EQ(header_length - 1,
             decoder_.ProcessInput(header.data() + 1, header_length - 1));
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
@@ -546,22 +540,20 @@
   // Use a reserved type that takes four bytes as a varint.
   const uint64_t frame_type = 0x1f * 0x222 + 0x21;
   const QuicByteCount payload_length = 0;
-  const QuicByteCount total_length =
+  const QuicByteCount header_length =
       QuicDataWriter::GetVarInt62Len(frame_type) +
       QuicDataWriter::GetVarInt62Len(payload_length);
 
-  auto input = QuicMakeUnique<char[]>(total_length);
-  QuicDataWriter writer(total_length, input.get());
+  auto input = QuicMakeUnique<char[]>(header_length);
+  QuicDataWriter writer(header_length, input.get());
   writer.WriteVarInt62(frame_type);
   writer.WriteVarInt62(payload_length);
 
-  EXPECT_CALL(visitor_,
-              OnUnknownFrameStart(
-                  frame_type, Http3FrameLengths(total_length, payload_length)));
+  EXPECT_CALL(visitor_, OnUnknownFrameStart(frame_type, header_length));
   EXPECT_CALL(visitor_, OnUnknownFrameEnd());
 
   auto raw_input = input.get();
-  for (uint64_t i = 0; i < total_length; ++i) {
+  for (uint64_t i = 0; i < header_length; ++i) {
     char c = raw_input[i];
     EXPECT_EQ(1u, decoder_.ProcessInput(&c, 1));
   }
@@ -606,8 +598,7 @@
       "Headers";  // headers
 
   // Visitor pauses processing.
-  EXPECT_CALL(visitor_, OnHeadersFrameStart(Http3FrameLengths(2, 7)))
-      .WillOnce(Return(false));
+  EXPECT_CALL(visitor_, OnHeadersFrameStart(2)).WillOnce(Return(false));
   QuicStringPiece remaining_input(input);
   QuicByteCount processed_bytes =
       ProcessInputWithGarbageAppended(remaining_input);
@@ -625,7 +616,7 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the full frame.
-  EXPECT_CALL(visitor_, OnHeadersFrameStart(Http3FrameLengths(2, 7)));
+  EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
   EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("Headers")));
   EXPECT_CALL(visitor_, OnHeadersFrameEnd());
   EXPECT_EQ(input.size(), ProcessInput(input));
@@ -633,7 +624,7 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the frame incrementally.
-  EXPECT_CALL(visitor_, OnHeadersFrameStart(Http3FrameLengths(2, 7)));
+  EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
   EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("H")));
   EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("e")));
   EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("a")));
@@ -655,8 +646,7 @@
       2);
 
   // Visitor pauses processing.
-  EXPECT_CALL(visitor_, OnDataFrameStart(Http3FrameLengths(2, 0)))
-      .WillOnce(Return(false));
+  EXPECT_CALL(visitor_, OnDataFrameStart(2)).WillOnce(Return(false));
   EXPECT_EQ(input.size(), ProcessInputWithGarbageAppended(input));
 
   EXPECT_CALL(visitor_, OnDataFrameEnd()).WillOnce(Return(false));
@@ -665,14 +655,14 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the full frame.
-  EXPECT_CALL(visitor_, OnDataFrameStart(Http3FrameLengths(2, 0)));
+  EXPECT_CALL(visitor_, OnDataFrameStart(2));
   EXPECT_CALL(visitor_, OnDataFrameEnd());
   EXPECT_EQ(input.size(), ProcessInput(input));
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the frame incrementally.
-  EXPECT_CALL(visitor_, OnDataFrameStart(Http3FrameLengths(2, 0)));
+  EXPECT_CALL(visitor_, OnDataFrameStart(2));
   EXPECT_CALL(visitor_, OnDataFrameEnd());
   ProcessInputCharByChar(input);
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
@@ -687,8 +677,7 @@
       2);
 
   // Visitor pauses processing.
-  EXPECT_CALL(visitor_, OnHeadersFrameStart(Http3FrameLengths(2, 0)))
-      .WillOnce(Return(false));
+  EXPECT_CALL(visitor_, OnHeadersFrameStart(2)).WillOnce(Return(false));
   EXPECT_EQ(input.size(), ProcessInputWithGarbageAppended(input));
 
   EXPECT_CALL(visitor_, OnHeadersFrameEnd()).WillOnce(Return(false));
@@ -697,14 +686,14 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the full frame.
-  EXPECT_CALL(visitor_, OnHeadersFrameStart(Http3FrameLengths(2, 0)));
+  EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
   EXPECT_CALL(visitor_, OnHeadersFrameEnd());
   EXPECT_EQ(input.size(), ProcessInput(input));
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the frame incrementally.
-  EXPECT_CALL(visitor_, OnHeadersFrameStart(Http3FrameLengths(2, 0)));
+  EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
   EXPECT_CALL(visitor_, OnHeadersFrameEnd());
   ProcessInputCharByChar(input);
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
@@ -719,7 +708,7 @@
       "\x01";  // Push Id
 
   // Visitor pauses processing.
-  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, Http3FrameLengths(2, 1), 1))
+  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, 2, 1))
       .WillOnce(Return(false));
   EXPECT_EQ(input.size(), ProcessInputWithGarbageAppended(input));
 
@@ -729,14 +718,14 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the full frame.
-  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, Http3FrameLengths(2, 1), 1));
+  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, 2, 1));
   EXPECT_CALL(visitor_, OnPushPromiseFrameEnd());
   EXPECT_EQ(input.size(), ProcessInput(input));
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
   EXPECT_EQ("", decoder_.error_detail());
 
   // Process the frame incrementally.
-  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, Http3FrameLengths(2, 1), 1));
+  EXPECT_CALL(visitor_, OnPushPromiseFrameStart(1, 2, 1));
   EXPECT_CALL(visitor_, OnPushPromiseFrameEnd());
   ProcessInputCharByChar(input);
   EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
@@ -782,7 +771,7 @@
       16);
 
   // Visitor pauses processing, maybe because header decompression is blocked.
-  EXPECT_CALL(visitor_, OnHeadersFrameStart(Http3FrameLengths(2, 7)));
+  EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
   EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("Headers")));
   EXPECT_CALL(visitor_, OnHeadersFrameEnd()).WillOnce(Return(false));
   QuicStringPiece remaining_input(input);
@@ -792,7 +781,7 @@
   remaining_input = remaining_input.substr(processed_bytes);
 
   // Process DATA frame.
-  EXPECT_CALL(visitor_, OnDataFrameStart(Http3FrameLengths(2, 5)));
+  EXPECT_CALL(visitor_, OnDataFrameStart(2));
   EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("Data!")));
   EXPECT_CALL(visitor_, OnDataFrameEnd());
 
diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index 8b26afc..f899e78 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -27,14 +27,14 @@
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 
-  bool OnPriorityFrameStart(Http3FrameLengths frame_lengths) override {
+  bool OnPriorityFrameStart(QuicByteCount header_length) override {
     if (stream_->session()->perspective() == Perspective::IS_CLIENT) {
       stream_->session()->connection()->CloseConnection(
           QUIC_HTTP_DECODER_ERROR, "Server must not send Priority frames.",
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
       return false;
     }
-    return stream_->OnPriorityFrameStart(frame_lengths);
+    return stream_->OnPriorityFrameStart(header_length);
   }
 
   bool OnPriorityFrame(const PriorityFrame& frame) override {
@@ -62,8 +62,8 @@
     return false;
   }
 
-  bool OnSettingsFrameStart(Http3FrameLengths frame_lengths) override {
-    return stream_->OnSettingsFrameStart(frame_lengths);
+  bool OnSettingsFrameStart(QuicByteCount header_length) override {
+    return stream_->OnSettingsFrameStart(header_length);
   }
 
   bool OnSettingsFrame(const SettingsFrame& frame) override {
@@ -75,7 +75,7 @@
     return false;
   }
 
-  bool OnDataFrameStart(Http3FrameLengths /*frame_lengths*/) override {
+  bool OnDataFrameStart(QuicByteCount /*header_length*/) override {
     CloseConnectionOnWrongFrame("Data");
     return false;
   }
@@ -90,7 +90,7 @@
     return false;
   }
 
-  bool OnHeadersFrameStart(Http3FrameLengths /*frame_length*/) override {
+  bool OnHeadersFrameStart(QuicByteCount /*frame_length*/) override {
     CloseConnectionOnWrongFrame("Headers");
     return false;
   }
@@ -106,7 +106,7 @@
   }
 
   bool OnPushPromiseFrameStart(PushId /*push_id*/,
-                               Http3FrameLengths /*frame_length*/,
+                               QuicByteCount /*frame_length*/,
                                QuicByteCount /*push_id_length*/) override {
     CloseConnectionOnWrongFrame("Push Promise");
     return false;
@@ -123,7 +123,7 @@
   }
 
   bool OnUnknownFrameStart(uint64_t /* frame_type */,
-                           Http3FrameLengths /* frame_length */) override {
+                           QuicByteCount /* frame_length */) override {
     // Ignore unknown frame types.
     return true;
   }
@@ -190,7 +190,7 @@
 }
 
 bool QuicReceiveControlStream::OnSettingsFrameStart(
-    Http3FrameLengths /* frame_lengths */) {
+    QuicByteCount /* header_length */) {
   if (settings_frame_received_) {
     // TODO(renjietang): Change error code to HTTP_UNEXPECTED_FRAME.
     session()->connection()->CloseConnection(
@@ -215,7 +215,7 @@
 }
 
 bool QuicReceiveControlStream::OnPriorityFrameStart(
-    Http3FrameLengths /* frame_lengths */) {
+    QuicByteCount /* header_length */) {
   DCHECK_EQ(Perspective::IS_SERVER, session()->perspective());
   return true;
 }
diff --git a/quic/core/http/quic_receive_control_stream.h b/quic/core/http/quic_receive_control_stream.h
index f83b980..84217ce 100644
--- a/quic/core/http/quic_receive_control_stream.h
+++ b/quic/core/http/quic_receive_control_stream.h
@@ -7,6 +7,7 @@
 
 #include "net/third_party/quiche/src/quic/core/http/http_decoder.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 
 namespace quic {
@@ -35,9 +36,9 @@
   class HttpDecoderVisitor;
 
   // Called from HttpDecoderVisitor.
-  bool OnSettingsFrameStart(Http3FrameLengths frame_lengths);
+  bool OnSettingsFrameStart(QuicByteCount header_length);
   bool OnSettingsFrame(const SettingsFrame& settings);
-  bool OnPriorityFrameStart(Http3FrameLengths frame_lengths);
+  bool OnPriorityFrameStart(QuicByteCount header_length);
   // TODO(renjietang): Decode Priority in HTTP/3 style.
   bool OnPriorityFrame(const PriorityFrame& priority);
 
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index 2e97a94..e926af7 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -47,7 +47,7 @@
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 
-  bool OnPriorityFrameStart(Http3FrameLengths /*frame_lengths*/) override {
+  bool OnPriorityFrameStart(QuicByteCount /*header_length*/) override {
     CloseConnectionOnWrongFrame("Priority");
     return false;
   }
@@ -72,7 +72,7 @@
     return false;
   }
 
-  bool OnSettingsFrameStart(Http3FrameLengths /*frame_lengths*/) override {
+  bool OnSettingsFrameStart(QuicByteCount /*header_length*/) override {
     CloseConnectionOnWrongFrame("Settings");
     return false;
   }
@@ -88,8 +88,8 @@
     return false;
   }
 
-  bool OnDataFrameStart(Http3FrameLengths frame_lengths) override {
-    return stream_->OnDataFrameStart(frame_lengths);
+  bool OnDataFrameStart(QuicByteCount header_length) override {
+    return stream_->OnDataFrameStart(header_length);
   }
 
   bool OnDataFramePayload(QuicStringPiece payload) override {
@@ -99,12 +99,12 @@
 
   bool OnDataFrameEnd() override { return stream_->OnDataFrameEnd(); }
 
-  bool OnHeadersFrameStart(Http3FrameLengths frame_length) override {
+  bool OnHeadersFrameStart(QuicByteCount header_length) override {
     if (!VersionUsesQpack(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Headers");
       return false;
     }
-    return stream_->OnHeadersFrameStart(frame_length);
+    return stream_->OnHeadersFrameStart(header_length);
   }
 
   bool OnHeadersFramePayload(QuicStringPiece payload) override {
@@ -125,13 +125,13 @@
   }
 
   bool OnPushPromiseFrameStart(PushId push_id,
-                               Http3FrameLengths frame_length,
+                               QuicByteCount header_length,
                                QuicByteCount push_id_length) override {
     if (!VersionHasStreamType(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Push Promise");
       return false;
     }
-    return stream_->OnPushPromiseFrameStart(push_id, frame_length,
+    return stream_->OnPushPromiseFrameStart(push_id, header_length,
                                             push_id_length);
   }
 
@@ -153,8 +153,8 @@
   }
 
   bool OnUnknownFrameStart(uint64_t frame_type,
-                           Http3FrameLengths frame_length) override {
-    return stream_->OnUnknownFrameStart(frame_type, frame_length);
+                           QuicByteCount header_length) override {
+    return stream_->OnUnknownFrameStart(frame_type, header_length);
   }
 
   bool OnUnknownFramePayload(QuicStringPiece payload) override {
@@ -784,7 +784,7 @@
   spdy_session_ = nullptr;
 }
 
-bool QuicSpdyStream::OnDataFrameStart(Http3FrameLengths frame_lengths) {
+bool QuicSpdyStream::OnDataFrameStart(QuicByteCount header_length) {
   DCHECK(VersionHasDataFrameHeader(transport_version()));
   if (!headers_decompressed_ || trailers_decompressed_) {
     // TODO(b/124216424): Change error code to HTTP_UNEXPECTED_FRAME.
@@ -794,8 +794,7 @@
     return false;
   }
 
-  sequencer()->MarkConsumed(
-      body_buffer_.OnNonBody(frame_lengths.header_length));
+  sequencer()->MarkConsumed(body_buffer_.OnNonBody(header_length));
 
   return true;
 }
@@ -862,7 +861,7 @@
   return header_acked_length;
 }
 
-bool QuicSpdyStream::OnHeadersFrameStart(Http3FrameLengths frame_length) {
+bool QuicSpdyStream::OnHeadersFrameStart(QuicByteCount header_length) {
   DCHECK(VersionUsesQpack(transport_version()));
   DCHECK(!qpack_decoded_headers_accumulator_);
 
@@ -875,13 +874,7 @@
     return false;
   }
 
-  sequencer()->MarkConsumed(body_buffer_.OnNonBody(frame_length.header_length));
-
-  if (headers_decompressed_) {
-    trailers_payload_length_ = frame_length.payload_length;
-  } else {
-    headers_payload_length_ = frame_length.payload_length;
-  }
+  sequencer()->MarkConsumed(body_buffer_.OnNonBody(header_length));
 
   qpack_decoded_headers_accumulator_ =
       QuicMakeUnique<QpackDecodedHeadersAccumulator>(
@@ -894,6 +887,12 @@
 bool QuicSpdyStream::OnHeadersFramePayload(QuicStringPiece payload) {
   DCHECK(VersionUsesQpack(transport_version()));
 
+  if (headers_decompressed_) {
+    trailers_payload_length_ += payload.length();
+  } else {
+    headers_payload_length_ += payload.length();
+  }
+
   const bool success = qpack_decoded_headers_accumulator_->Decode(payload);
 
   sequencer()->MarkConsumed(body_buffer_.OnNonBody(payload.size()));
@@ -935,7 +934,7 @@
 }
 
 bool QuicSpdyStream::OnPushPromiseFrameStart(PushId push_id,
-                                             Http3FrameLengths frame_length,
+                                             QuicByteCount header_length,
                                              QuicByteCount push_id_length) {
   DCHECK(VersionHasStreamType(transport_version()));
   DCHECK(!qpack_decoded_headers_accumulator_);
@@ -943,7 +942,7 @@
   // TODO(renjietang): Check max push id and handle errors.
   spdy_session_->OnPushPromise(id(), push_id);
   sequencer()->MarkConsumed(
-      body_buffer_.OnNonBody(frame_length.header_length + push_id_length));
+      body_buffer_.OnNonBody(header_length + push_id_length));
 
   qpack_decoded_headers_accumulator_ =
       QuicMakeUnique<QpackDecodedHeadersAccumulator>(
@@ -965,14 +964,12 @@
 }
 
 bool QuicSpdyStream::OnUnknownFrameStart(uint64_t frame_type,
-                                         Http3FrameLengths frame_length) {
+                                         QuicByteCount header_length) {
   // Ignore unknown frames, but consume frame header.
-  QUIC_DVLOG(1) << "Discarding " << frame_length.header_length
+  QUIC_DVLOG(1) << "Discarding " << header_length
                 << " byte long frame header of frame of unknown type "
                 << frame_type << ".";
-  QUIC_DVLOG(1) << "Frame total payload length is "
-                << frame_length.payload_length << ".";
-  sequencer()->MarkConsumed(body_buffer_.OnNonBody(frame_length.header_length));
+  sequencer()->MarkConsumed(body_buffer_.OnNonBody(header_length));
   return true;
 }
 
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index 48cb948..cc873bb 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -252,18 +252,18 @@
   class HttpDecoderVisitor;
 
   // Called by HttpDecoderVisitor.
-  bool OnDataFrameStart(Http3FrameLengths frame_lengths);
+  bool OnDataFrameStart(QuicByteCount header_length);
   bool OnDataFramePayload(QuicStringPiece payload);
   bool OnDataFrameEnd();
-  bool OnHeadersFrameStart(Http3FrameLengths frame_length);
+  bool OnHeadersFrameStart(QuicByteCount header_length);
   bool OnHeadersFramePayload(QuicStringPiece payload);
   bool OnHeadersFrameEnd();
   bool OnPushPromiseFrameStart(PushId push_id,
-                               Http3FrameLengths frame_length,
+                               QuicByteCount header_length,
                                QuicByteCount push_id_length);
   bool OnPushPromiseFramePayload(QuicStringPiece payload);
   bool OnPushPromiseFrameEnd();
-  bool OnUnknownFrameStart(uint64_t frame_type, Http3FrameLengths frame_length);
+  bool OnUnknownFrameStart(uint64_t frame_type, QuicByteCount header_length);
   bool OnUnknownFramePayload(QuicStringPiece payload);
   bool OnUnknownFrameEnd();