Implement PRIORITY_UPDATE frame in HTTP/2 decoder. Protected by FLAGS_gfe2_restart_flag_http2_parse_priority_update_frame. PiperOrigin-RevId: 350771697 Change-Id: Ia630bd2d2a2211c8f6238676f6024dcf7ada924d

diff --git a/http2/decoder/decode_http2_structures.cc b/http2/decoder/decode_http2_structures.cc
index 9d57058..2f0b06e 100644
--- a/http2/decoder/decode_http2_structures.cc
+++ b/http2/decoder/decode_http2_structures.cc

@@ -100,6 +100,15 @@
   out->window_size_increment = b->DecodeUInt31();
 }
 
+// Http2PriorityUpdateFields decoding:
+
+void DoDecode(Http2PriorityUpdateFields* out, DecodeBuffer* b) {
+  DCHECK_NE(nullptr, out);
+  DCHECK_NE(nullptr, b);
+  DCHECK_LE(Http2PriorityUpdateFields::EncodedSize(), b->Remaining());
+  out->prioritized_stream_id = b->DecodeUInt31();
+}
+
 // Http2AltSvcFields decoding:
 
 void DoDecode(Http2AltSvcFields* out, DecodeBuffer* b) {

diff --git a/http2/decoder/decode_http2_structures.h b/http2/decoder/decode_http2_structures.h
index 4cb93a3..9b26d33 100644
--- a/http2/decoder/decode_http2_structures.h
+++ b/http2/decoder/decode_http2_structures.h

@@ -28,6 +28,8 @@
 QUICHE_EXPORT_PRIVATE void DoDecode(Http2WindowUpdateFields* out,
                                     DecodeBuffer* b);
 QUICHE_EXPORT_PRIVATE void DoDecode(Http2AltSvcFields* out, DecodeBuffer* b);
+QUICHE_EXPORT_PRIVATE void DoDecode(Http2PriorityUpdateFields* out,
+                                    DecodeBuffer* b);
 
 }  // namespace http2
 

diff --git a/http2/decoder/http2_frame_decoder.cc b/http2/decoder/http2_frame_decoder.cc
index dc04c20..e395a27 100644
--- a/http2/decoder/http2_frame_decoder.cc
+++ b/http2/decoder/http2_frame_decoder.cc

@@ -8,6 +8,8 @@
 #include "http2/hpack/varint/hpack_varint_decoder.h"
 #include "http2/http2_constants.h"
 #include "http2/platform/api/http2_bug_tracker.h"
+#include "http2/platform/api/http2_flag_utils.h"
+#include "http2/platform/api/http2_flags.h"
 #include "http2/platform/api/http2_macros.h"
 
 namespace http2 {
@@ -155,6 +157,15 @@
       status = StartDecodingAltSvcPayload(&subset);
       break;
 
+    case Http2FrameType::PRIORITY_UPDATE:
+      if (GetHttp2RestartFlag(http2_parse_priority_update_frame)) {
+        HTTP2_RESTART_FLAG_COUNT_N(http2_parse_priority_update_frame, 1, 2);
+        status = StartDecodingPriorityUpdatePayload(&subset);
+      } else {
+        status = StartDecodingUnknownPayload(&subset);
+      }
+      break;
+
     default:
       status = StartDecodingUnknownPayload(&subset);
       break;
@@ -225,6 +236,15 @@
       status = ResumeDecodingAltSvcPayload(&subset);
       break;
 
+    case Http2FrameType::PRIORITY_UPDATE:
+      if (GetHttp2RestartFlag(http2_parse_priority_update_frame)) {
+        HTTP2_RESTART_FLAG_COUNT_N(http2_parse_priority_update_frame, 2, 2);
+        status = ResumeDecodingPriorityUpdatePayload(&subset);
+      } else {
+        status = ResumeDecodingUnknownPayload(&subset);
+      }
+      break;
+
     default:
       status = ResumeDecodingUnknownPayload(&subset);
       break;
@@ -339,6 +359,21 @@
                                                          db);
 }
 
+DecodeStatus Http2FrameDecoder::StartDecodingPriorityUpdatePayload(
+    DecodeBuffer* db) {
+  ClearFlags();
+  return priority_payload_update_decoder_.StartDecodingPayload(
+      &frame_decoder_state_, db);
+}
+DecodeStatus Http2FrameDecoder::ResumeDecodingPriorityUpdatePayload(
+    DecodeBuffer* db) {
+  // The frame is not paddable.
+  DCHECK_EQ(frame_decoder_state_.remaining_total_payload(),
+            frame_decoder_state_.remaining_payload());
+  return priority_payload_update_decoder_.ResumeDecodingPayload(
+      &frame_decoder_state_, db);
+}
+
 DecodeStatus Http2FrameDecoder::StartDecodingPushPromisePayload(
     DecodeBuffer* db) {
   RetainFlags(Http2FrameFlag::END_HEADERS | Http2FrameFlag::PADDED);

diff --git a/http2/decoder/http2_frame_decoder.h b/http2/decoder/http2_frame_decoder.h
index cb8f15b..53e4bbe 100644
--- a/http2/decoder/http2_frame_decoder.h
+++ b/http2/decoder/http2_frame_decoder.h

@@ -32,6 +32,7 @@
 #include "http2/decoder/payload_decoders/headers_payload_decoder.h"
 #include "http2/decoder/payload_decoders/ping_payload_decoder.h"
 #include "http2/decoder/payload_decoders/priority_payload_decoder.h"
+#include "http2/decoder/payload_decoders/priority_update_payload_decoder.h"
 #include "http2/decoder/payload_decoders/push_promise_payload_decoder.h"
 #include "http2/decoder/payload_decoders/rst_stream_payload_decoder.h"
 #include "http2/decoder/payload_decoders/settings_payload_decoder.h"
@@ -148,6 +149,7 @@
   DecodeStatus StartDecodingHeadersPayload(DecodeBuffer* db);
   DecodeStatus StartDecodingPingPayload(DecodeBuffer* db);
   DecodeStatus StartDecodingPriorityPayload(DecodeBuffer* db);
+  DecodeStatus StartDecodingPriorityUpdatePayload(DecodeBuffer* db);
   DecodeStatus StartDecodingPushPromisePayload(DecodeBuffer* db);
   DecodeStatus StartDecodingRstStreamPayload(DecodeBuffer* db);
   DecodeStatus StartDecodingSettingsPayload(DecodeBuffer* db);
@@ -169,6 +171,7 @@
   DecodeStatus ResumeDecodingHeadersPayload(DecodeBuffer* db);
   DecodeStatus ResumeDecodingPingPayload(DecodeBuffer* db);
   DecodeStatus ResumeDecodingPriorityPayload(DecodeBuffer* db);
+  DecodeStatus ResumeDecodingPriorityUpdatePayload(DecodeBuffer* db);
   DecodeStatus ResumeDecodingPushPromisePayload(DecodeBuffer* db);
   DecodeStatus ResumeDecodingRstStreamPayload(DecodeBuffer* db);
   DecodeStatus ResumeDecodingSettingsPayload(DecodeBuffer* db);
@@ -186,6 +189,7 @@
     HeadersPayloadDecoder headers_payload_decoder_;
     PingPayloadDecoder ping_payload_decoder_;
     PriorityPayloadDecoder priority_payload_decoder_;
+    PriorityUpdatePayloadDecoder priority_payload_update_decoder_;
     PushPromisePayloadDecoder push_promise_payload_decoder_;
     RstStreamPayloadDecoder rst_stream_payload_decoder_;
     SettingsPayloadDecoder settings_payload_decoder_;

diff --git a/http2/decoder/http2_frame_decoder_listener.h b/http2/decoder/http2_frame_decoder_listener.h
index 5482251..9bb1688 100644
--- a/http2/decoder/http2_frame_decoder_listener.h
+++ b/http2/decoder/http2_frame_decoder_listener.h

@@ -247,6 +247,28 @@
   // via the above methods.
   virtual void OnAltSvcEnd() = 0;
 
+  // Called when an PRIORITY_UPDATE frame header and Prioritized Stream ID have
+  // been parsed.  Afterwards:
+  //   OnPriorityUpdatePayload will be called each time a portion of the
+  //     Priority Field Value field is available until all of it has been
+  //     provided;
+  //   OnPriorityUpdateEnd will be called last. If the frame has an empty
+  //     Priority Field Value, then this will be called immediately after
+  //     OnPriorityUpdateStart.
+  virtual void OnPriorityUpdateStart(
+      const Http2FrameHeader& header,
+      const Http2PriorityUpdateFields& priority_update) = 0;
+
+  // Called when the next portion of a PRIORITY_UPDATE frame's Priority Field
+  // Value field is received.
+  // |data| The start of |len| bytes of data.
+  // |len| The length of the data buffer. May be zero in some cases, which does
+  //     not mean anything special.
+  virtual void OnPriorityUpdatePayload(const char* data, size_t len) = 0;
+
+  // Called after an entire PRIORITY_UPDATE frame has been received.
+  virtual void OnPriorityUpdateEnd() = 0;
+
   // Called when the common frame header has been decoded, but the frame type
   // is unknown, after which:
   //   OnUnknownPayload is called as the payload of the frame is provided to the
@@ -341,6 +363,11 @@
   void OnAltSvcOriginData(const char* /*data*/, size_t /*len*/) override {}
   void OnAltSvcValueData(const char* /*data*/, size_t /*len*/) override {}
   void OnAltSvcEnd() override {}
+  void OnPriorityUpdateStart(
+      const Http2FrameHeader& /*header*/,
+      const Http2PriorityUpdateFields& /*priority_update*/) override {}
+  void OnPriorityUpdatePayload(const char* /*data*/, size_t /*len*/) override {}
+  void OnPriorityUpdateEnd() override {}
   void OnUnknownStart(const Http2FrameHeader& /*header*/) override {}
   void OnUnknownPayload(const char* /*data*/, size_t /*len*/) override {}
   void OnUnknownEnd() override {}

diff --git a/http2/decoder/http2_frame_decoder_listener_test_util.cc b/http2/decoder/http2_frame_decoder_listener_test_util.cc
index e35caf6..ddd0064 100644
--- a/http2/decoder/http2_frame_decoder_listener_test_util.cc
+++ b/http2/decoder/http2_frame_decoder_listener_test_util.cc

@@ -168,6 +168,23 @@
   FAIL() << "OnAltSvcEnd";
 }
 
+void FailingHttp2FrameDecoderListener::OnPriorityUpdateStart(
+    const Http2FrameHeader& header,
+    const Http2PriorityUpdateFields& priority_update) {
+  FAIL() << "OnPriorityUpdateStart: " << header << "; prioritized_stream_id: "
+         << priority_update.prioritized_stream_id;
+}
+
+void FailingHttp2FrameDecoderListener::OnPriorityUpdatePayload(
+    const char* /*data*/,
+    size_t len) {
+  FAIL() << "OnPriorityUpdatePayload: len=" << len;
+}
+
+void FailingHttp2FrameDecoderListener::OnPriorityUpdateEnd() {
+  FAIL() << "OnPriorityUpdateEnd";
+}
+
 void FailingHttp2FrameDecoderListener::OnUnknownStart(
     const Http2FrameHeader& header) {
   FAIL() << "OnUnknownStart: " << header;
@@ -445,6 +462,30 @@
   }
 }
 
+void LoggingHttp2FrameDecoderListener::OnPriorityUpdateStart(
+    const Http2FrameHeader& header,
+    const Http2PriorityUpdateFields& priority_update) {
+  HTTP2_VLOG(1) << "OnPriorityUpdateStart";
+  if (wrapped_ != nullptr) {
+    wrapped_->OnPriorityUpdateStart(header, priority_update);
+  }
+}
+
+void LoggingHttp2FrameDecoderListener::OnPriorityUpdatePayload(const char* data,
+                                                               size_t len) {
+  HTTP2_VLOG(1) << "OnPriorityUpdatePayload";
+  if (wrapped_ != nullptr) {
+    wrapped_->OnPriorityUpdatePayload(data, len);
+  }
+}
+
+void LoggingHttp2FrameDecoderListener::OnPriorityUpdateEnd() {
+  HTTP2_VLOG(1) << "OnPriorityUpdateEnd";
+  if (wrapped_ != nullptr) {
+    wrapped_->OnPriorityUpdateEnd();
+  }
+}
+
 void LoggingHttp2FrameDecoderListener::OnUnknownStart(
     const Http2FrameHeader& header) {
   HTTP2_VLOG(1) << "OnUnknownStart: " << header;

diff --git a/http2/decoder/http2_frame_decoder_listener_test_util.h b/http2/decoder/http2_frame_decoder_listener_test_util.h
index da5a87c..e748327 100644
--- a/http2/decoder/http2_frame_decoder_listener_test_util.h
+++ b/http2/decoder/http2_frame_decoder_listener_test_util.h

@@ -64,6 +64,11 @@
   void OnAltSvcOriginData(const char* data, size_t len) override;
   void OnAltSvcValueData(const char* data, size_t len) override;
   void OnAltSvcEnd() override;
+  void OnPriorityUpdateStart(
+      const Http2FrameHeader& header,
+      const Http2PriorityUpdateFields& priority_update) override;
+  void OnPriorityUpdatePayload(const char* data, size_t len) override;
+  void OnPriorityUpdateEnd() override;
   void OnUnknownStart(const Http2FrameHeader& header) override;
   void OnUnknownPayload(const char* data, size_t len) override;
   void OnUnknownEnd() override;
@@ -125,6 +130,11 @@
   void OnAltSvcOriginData(const char* data, size_t len) override;
   void OnAltSvcValueData(const char* data, size_t len) override;
   void OnAltSvcEnd() override;
+  void OnPriorityUpdateStart(
+      const Http2FrameHeader& header,
+      const Http2PriorityUpdateFields& priority_update) override;
+  void OnPriorityUpdatePayload(const char* data, size_t len) override;
+  void OnPriorityUpdateEnd() override;
   void OnUnknownStart(const Http2FrameHeader& header) override;
   void OnUnknownPayload(const char* data, size_t len) override;
   void OnUnknownEnd() override;

diff --git a/http2/decoder/http2_frame_decoder_test.cc b/http2/decoder/http2_frame_decoder_test.cc
index 883c84b..0b0b415 100644
--- a/http2/decoder/http2_frame_decoder_test.cc
+++ b/http2/decoder/http2_frame_decoder_test.cc

@@ -11,6 +11,7 @@
 
 #include "absl/strings/string_view.h"
 #include "http2/http2_constants.h"
+#include "http2/platform/api/http2_flags.h"
 #include "http2/platform/api/http2_logging.h"
 #include "http2/platform/api/http2_test_helpers.h"
 #include "http2/test_tools/frame_parts.h"
@@ -546,6 +547,29 @@
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
+TEST_F(Http2FrameDecoderTest, PriorityUpdatePayload) {
+  const char kFrameData[] = {
+      '\x00', '\x00', '\x07',          // Payload length: 7
+      '\x10',                          // PRIORITY_UPDATE
+      '\x00',                          // Flags: none
+      '\x00', '\x00', '\x00', '\x00',  // Stream ID: 0
+      '\x00', '\x00', '\x00', '\x05',  // Prioritized Stream ID: 5
+      'a',    'b',    'c',             // Priority Field Value
+  };
+  Http2FrameHeader header(7, Http2FrameType::PRIORITY_UPDATE, 0, 0);
+
+  if (GetHttp2RestartFlag(http2_parse_priority_update_frame)) {
+    FrameParts expected(header, "abc");
+    expected.SetOptPriorityUpdate(Http2PriorityUpdateFields{5});
+    EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
+  } else {
+    FrameParts expected(header, absl::string_view("\x00\x00\x00\x05"
+                                                  "abc",
+                                                  7));
+    EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
+  }
+}
+
 TEST_F(Http2FrameDecoderTest, UnknownPayload) {
   const char kFrameData[] = {
       '\x00', '\x00', '\x03',          // Payload length: 3

diff --git a/http2/decoder/payload_decoders/priority_update_payload_decoder.cc b/http2/decoder/payload_decoders/priority_update_payload_decoder.cc
new file mode 100644
index 0000000..ec52c20
--- /dev/null
+++ b/http2/decoder/payload_decoders/priority_update_payload_decoder.cc

@@ -0,0 +1,125 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "http2/decoder/payload_decoders/priority_update_payload_decoder.h"
+
+#include <stddef.h>
+
+#include "http2/decoder/decode_buffer.h"
+#include "http2/decoder/http2_frame_decoder_listener.h"
+#include "http2/http2_constants.h"
+#include "http2/http2_structures.h"
+#include "http2/platform/api/http2_bug_tracker.h"
+#include "http2/platform/api/http2_logging.h"
+#include "http2/platform/api/http2_macros.h"
+
+namespace http2 {
+
+std::ostream& operator<<(std::ostream& out,
+                         PriorityUpdatePayloadDecoder::PayloadState v) {
+  switch (v) {
+    case PriorityUpdatePayloadDecoder::PayloadState::kStartDecodingFixedFields:
+      return out << "kStartDecodingFixedFields";
+    case PriorityUpdatePayloadDecoder::PayloadState::kResumeDecodingFixedFields:
+      return out << "kResumeDecodingFixedFields";
+    case PriorityUpdatePayloadDecoder::PayloadState::kHandleFixedFieldsStatus:
+      return out << "kHandleFixedFieldsStatus";
+    case PriorityUpdatePayloadDecoder::PayloadState::kReadPriorityFieldValue:
+      return out << "kReadPriorityFieldValue";
+  }
+  // Since the value doesn't come over the wire, only a programming bug should
+  // result in reaching this point.
+  int unknown = static_cast<int>(v);
+  HTTP2_BUG << "Invalid PriorityUpdatePayloadDecoder::PayloadState: "
+            << unknown;
+  return out << "PriorityUpdatePayloadDecoder::PayloadState(" << unknown << ")";
+}
+
+DecodeStatus PriorityUpdatePayloadDecoder::StartDecodingPayload(
+    FrameDecoderState* state,
+    DecodeBuffer* db) {
+  HTTP2_DVLOG(2) << "PriorityUpdatePayloadDecoder::StartDecodingPayload: "
+                 << state->frame_header();
+  DCHECK_EQ(Http2FrameType::PRIORITY_UPDATE, state->frame_header().type);
+  DCHECK_LE(db->Remaining(), state->frame_header().payload_length);
+  DCHECK_EQ(0, state->frame_header().flags);
+
+  state->InitializeRemainders();
+  payload_state_ = PayloadState::kStartDecodingFixedFields;
+  return ResumeDecodingPayload(state, db);
+}
+
+DecodeStatus PriorityUpdatePayloadDecoder::ResumeDecodingPayload(
+    FrameDecoderState* state,
+    DecodeBuffer* db) {
+  HTTP2_DVLOG(2) << "PriorityUpdatePayloadDecoder::ResumeDecodingPayload: "
+                    "remaining_payload="
+                 << state->remaining_payload()
+                 << ", db->Remaining=" << db->Remaining();
+
+  const Http2FrameHeader& frame_header = state->frame_header();
+  DCHECK_EQ(Http2FrameType::PRIORITY_UPDATE, frame_header.type);
+  DCHECK_LE(db->Remaining(), frame_header.payload_length);
+  DCHECK_NE(PayloadState::kHandleFixedFieldsStatus, payload_state_);
+
+  // |status| has to be initialized to some value to avoid compiler error in
+  // case PayloadState::kHandleFixedFieldsStatus below, but value does not
+  // matter, see DCHECK_NE above.
+  DecodeStatus status = DecodeStatus::kDecodeError;
+  size_t avail;
+  while (true) {
+    HTTP2_DVLOG(2)
+        << "PriorityUpdatePayloadDecoder::ResumeDecodingPayload payload_state_="
+        << payload_state_;
+    switch (payload_state_) {
+      case PayloadState::kStartDecodingFixedFields:
+        status = state->StartDecodingStructureInPayload(
+            &priority_update_fields_, db);
+        HTTP2_FALLTHROUGH;
+
+      case PayloadState::kHandleFixedFieldsStatus:
+        if (status == DecodeStatus::kDecodeDone) {
+          state->listener()->OnPriorityUpdateStart(frame_header,
+                                                   priority_update_fields_);
+        } else {
+          // Not done decoding the structure. Either we've got more payload
+          // to decode, or we've run out because the payload is too short,
+          // in which case OnFrameSizeError will have already been called.
+          DCHECK((status == DecodeStatus::kDecodeInProgress &&
+                  state->remaining_payload() > 0) ||
+                 (status == DecodeStatus::kDecodeError &&
+                  state->remaining_payload() == 0))
+              << "\n status=" << status
+              << "; remaining_payload=" << state->remaining_payload();
+          payload_state_ = PayloadState::kResumeDecodingFixedFields;
+          return status;
+        }
+        HTTP2_FALLTHROUGH;
+
+      case PayloadState::kReadPriorityFieldValue:
+        // Anything left in the decode buffer is the Priority Field Value.
+        avail = db->Remaining();
+        if (avail > 0) {
+          state->listener()->OnPriorityUpdatePayload(db->cursor(), avail);
+          db->AdvanceCursor(avail);
+          state->ConsumePayload(avail);
+        }
+        if (state->remaining_payload() > 0) {
+          payload_state_ = PayloadState::kReadPriorityFieldValue;
+          return DecodeStatus::kDecodeInProgress;
+        }
+        state->listener()->OnPriorityUpdateEnd();
+        return DecodeStatus::kDecodeDone;
+
+      case PayloadState::kResumeDecodingFixedFields:
+        status = state->ResumeDecodingStructureInPayload(
+            &priority_update_fields_, db);
+        payload_state_ = PayloadState::kHandleFixedFieldsStatus;
+        continue;
+    }
+    HTTP2_BUG << "PayloadState: " << payload_state_;
+  }
+}
+
+}  // namespace http2

diff --git a/http2/decoder/payload_decoders/priority_update_payload_decoder.h b/http2/decoder/payload_decoders/priority_update_payload_decoder.h
new file mode 100644
index 0000000..f2557b2
--- /dev/null
+++ b/http2/decoder/payload_decoders/priority_update_payload_decoder.h

@@ -0,0 +1,63 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_HTTP2_DECODER_PAYLOAD_DECODERS_PRIORITY_UPDATE_PAYLOAD_DECODER_H_
+#define QUICHE_HTTP2_DECODER_PAYLOAD_DECODERS_PRIORITY_UPDATE_PAYLOAD_DECODER_H_
+
+// Decodes the payload of a PRIORITY_UPDATE frame.
+
+#include "http2/decoder/decode_buffer.h"
+#include "http2/decoder/decode_status.h"
+#include "http2/decoder/frame_decoder_state.h"
+#include "http2/http2_structures.h"
+#include "common/platform/api/quiche_export.h"
+
+namespace http2 {
+namespace test {
+class PriorityUpdatePayloadDecoderPeer;
+}  // namespace test
+
+class QUICHE_EXPORT_PRIVATE PriorityUpdatePayloadDecoder {
+ public:
+  // States during decoding of a PRIORITY_UPDATE frame.
+  enum class PayloadState {
+    // At the start of the PRIORITY_UPDATE frame payload, ready to start
+    // decoding the fixed size fields into priority_update_fields_.
+    kStartDecodingFixedFields,
+
+    // The fixed size fields weren't all available when the decoder first
+    // tried to decode them; this state resumes the decoding when
+    // ResumeDecodingPayload is called later.
+    kResumeDecodingFixedFields,
+
+    // Handle the DecodeStatus returned from starting or resuming the decoding
+    // of Http2PriorityUpdateFields into priority_update_fields_. If complete,
+    // calls OnPriorityUpdateStart.
+    kHandleFixedFieldsStatus,
+
+    // Report the Priority Field Value portion of the payload to the listener's
+    // OnPriorityUpdatePayload method, and call OnPriorityUpdateEnd when the end
+    // of the payload is reached.
+    kReadPriorityFieldValue,
+  };
+
+  // Starts the decoding of a PRIORITY_UPDATE frame's payload, and completes it
+  // if the entire payload is in the provided decode buffer.
+  DecodeStatus StartDecodingPayload(FrameDecoderState* state, DecodeBuffer* db);
+
+  // Resumes decoding a PRIORITY_UPDATE frame that has been split across decode
+  // buffers.
+  DecodeStatus ResumeDecodingPayload(FrameDecoderState* state,
+                                     DecodeBuffer* db);
+
+ private:
+  friend class test::PriorityUpdatePayloadDecoderPeer;
+
+  Http2PriorityUpdateFields priority_update_fields_;
+  PayloadState payload_state_;
+};
+
+}  // namespace http2
+
+#endif  // QUICHE_HTTP2_DECODER_PAYLOAD_DECODERS_PRIORITY_UPDATE_PAYLOAD_DECODER_H_

diff --git a/http2/decoder/payload_decoders/priority_update_payload_decoder_test.cc b/http2/decoder/payload_decoders/priority_update_payload_decoder_test.cc
new file mode 100644
index 0000000..39d0afc
--- /dev/null
+++ b/http2/decoder/payload_decoders/priority_update_payload_decoder_test.cc

@@ -0,0 +1,135 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "http2/decoder/payload_decoders/priority_update_payload_decoder.h"
+
+#include <stddef.h>
+
+#include <string>
+
+#include "http2/decoder/http2_frame_decoder_listener.h"
+#include "http2/decoder/payload_decoders/payload_decoder_base_test_util.h"
+#include "http2/http2_constants.h"
+#include "http2/http2_structures_test_util.h"
+#include "http2/platform/api/http2_logging.h"
+#include "http2/test_tools/frame_parts.h"
+#include "http2/test_tools/frame_parts_collector.h"
+#include "http2/test_tools/http2_random.h"
+#include "http2/tools/http2_frame_builder.h"
+#include "http2/tools/random_decoder_test.h"
+#include "common/platform/api/quiche_test.h"
+
+namespace http2 {
+namespace test {
+
+class PriorityUpdatePayloadDecoderPeer {
+ public:
+  static constexpr Http2FrameType FrameType() {
+    return Http2FrameType::PRIORITY_UPDATE;
+  }
+
+  // Returns the mask of flags that affect the decoding of the payload (i.e.
+  // flags that that indicate the presence of certain fields or padding).
+  static constexpr uint8_t FlagsAffectingPayloadDecoding() { return 0; }
+};
+
+namespace {
+
+struct Listener : public FramePartsCollector {
+  void OnPriorityUpdateStart(
+      const Http2FrameHeader& header,
+      const Http2PriorityUpdateFields& priority_update) override {
+    HTTP2_VLOG(1) << "OnPriorityUpdateStart header: " << header
+                  << "; priority_update: " << priority_update;
+    StartFrame(header)->OnPriorityUpdateStart(header, priority_update);
+  }
+
+  void OnPriorityUpdatePayload(const char* data, size_t len) override {
+    HTTP2_VLOG(1) << "OnPriorityUpdatePayload: len=" << len;
+    CurrentFrame()->OnPriorityUpdatePayload(data, len);
+  }
+
+  void OnPriorityUpdateEnd() override {
+    HTTP2_VLOG(1) << "OnPriorityUpdateEnd";
+    EndFrame()->OnPriorityUpdateEnd();
+  }
+
+  void OnFrameSizeError(const Http2FrameHeader& header) override {
+    HTTP2_VLOG(1) << "OnFrameSizeError: " << header;
+    FrameError(header)->OnFrameSizeError(header);
+  }
+};
+
+// Avoid initialization of test class when flag is false, because base class
+// method AbstractPayloadDecoderTest::SetUp() crashes if
+// IsSupportedHttp2FrameType(PRIORITY_UPDATE) returns false.
+std::vector<bool> GetTestParams() {
+  if (GetHttp2RestartFlag(http2_parse_priority_update_frame)) {
+    return {true};  // Actual Boolean value is ignored.
+  } else {
+    return {};
+  }
+}
+
+class PriorityUpdatePayloadDecoderTest
+    : public AbstractPayloadDecoderTest<PriorityUpdatePayloadDecoder,
+                                        PriorityUpdatePayloadDecoderPeer,
+                                        Listener>,
+      public ::testing::WithParamInterface<bool> {};
+
+INSTANTIATE_TEST_SUITE_P(MaybeRunTest,
+                         PriorityUpdatePayloadDecoderTest,
+                         ::testing::ValuesIn(GetTestParams()));
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PriorityUpdatePayloadDecoderTest);
+
+// Confirm we get an error if the payload is not long enough to hold
+// Http2PriorityUpdateFields.
+TEST_P(PriorityUpdatePayloadDecoderTest, Truncated) {
+  auto approve_size = [](size_t size) {
+    return size != Http2PriorityUpdateFields::EncodedSize();
+  };
+  Http2FrameBuilder fb;
+  fb.Append(Http2PriorityUpdateFields(123));
+  EXPECT_TRUE(VerifyDetectsFrameSizeError(0, fb.buffer(), approve_size));
+}
+
+class PriorityUpdatePayloadLengthTests
+    : public AbstractPayloadDecoderTest<PriorityUpdatePayloadDecoder,
+                                        PriorityUpdatePayloadDecoderPeer,
+                                        Listener>,
+      public ::testing::WithParamInterface<std::tuple<uint32_t, bool>> {
+ protected:
+  PriorityUpdatePayloadLengthTests() : length_(std::get<0>(GetParam())) {
+    HTTP2_VLOG(1) << "################  length_=" << length_
+                  << "  ################";
+  }
+
+  const uint32_t length_;
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    VariousLengths,
+    PriorityUpdatePayloadLengthTests,
+    ::testing::Combine(::testing::Values(0, 1, 2, 3, 4, 5, 6),
+                       ::testing::ValuesIn(GetTestParams())));
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PriorityUpdatePayloadLengthTests);
+
+TEST_P(PriorityUpdatePayloadLengthTests, ValidLength) {
+  Http2PriorityUpdateFields priority_update;
+  Randomize(&priority_update, RandomPtr());
+  std::string priority_field_value = Random().RandString(length_);
+  Http2FrameBuilder fb;
+  fb.Append(priority_update);
+  fb.Append(priority_field_value);
+  Http2FrameHeader header(fb.size(), Http2FrameType::PRIORITY_UPDATE,
+                          RandFlags(), RandStreamId());
+  set_frame_header(header);
+  FrameParts expected(header, priority_field_value);
+  expected.SetOptPriorityUpdate(Http2PriorityUpdateFields{priority_update});
+  ASSERT_TRUE(DecodePayloadAndValidateSeveralWays(fb.buffer(), expected));
+}
+
+}  // namespace
+}  // namespace test
+}  // namespace http2

diff --git a/http2/http2_constants.cc b/http2/http2_constants.cc
index 0c4a587..1cc6b17 100644
--- a/http2/http2_constants.cc
+++ b/http2/http2_constants.cc

@@ -35,6 +35,8 @@
       return "CONTINUATION";
     case Http2FrameType::ALTSVC:
       return "ALTSVC";
+    case Http2FrameType::PRIORITY_UPDATE:
+      return "PRIORITY_UPDATE";
   }
   return absl::StrCat("UnknownFrameType(", static_cast<int>(v), ")");
 }

diff --git a/http2/http2_constants.h b/http2/http2_constants.h
index f3073ac..cd05eb4 100644
--- a/http2/http2_constants.h
+++ b/http2/http2_constants.h

@@ -12,6 +12,7 @@
 #include <ostream>
 #include <string>
 
+#include "http2/platform/api/http2_flags.h"
 #include "common/platform/api/quiche_export.h"
 
 namespace http2 {
@@ -28,8 +29,6 @@
 
 // The value used to identify types of frames. Upper case to match the RFC.
 // The comments indicate which flags are valid for that frame type.
-// ALTSVC is defined in http://httpwg.org/http-extensions/alt-svc.html
-// (not yet final standard as of March 2016, but close).
 enum class Http2FrameType : uint8_t {
   DATA = 0,           // END_STREAM | PADDED
   HEADERS = 1,        // END_STREAM | END_HEADERS | PADDED | PRIORITY
@@ -41,11 +40,19 @@
   GOAWAY = 7,         //
   WINDOW_UPDATE = 8,  //
   CONTINUATION = 9,   // END_HEADERS
-  ALTSVC = 10,        //
+  // https://tools.ietf.org/html/rfc7838
+  ALTSVC = 10,  // no flags
+  // https://tools.ietf.org/html/draft-ietf-httpbis-priority-02
+  PRIORITY_UPDATE = 16,  // no flags
 };
 
 // Is the frame type known/supported?
 inline bool IsSupportedHttp2FrameType(uint32_t v) {
+  if (GetHttp2RestartFlag(http2_parse_priority_update_frame) &&
+      v == static_cast<uint32_t>(Http2FrameType::PRIORITY_UPDATE)) {
+    return true;
+  }
+
   return v <= static_cast<uint32_t>(Http2FrameType::ALTSVC);
 }
 inline bool IsSupportedHttp2FrameType(Http2FrameType v) {

diff --git a/http2/http2_structures.cc b/http2/http2_structures.cc
index f9b2405..dda0dd8 100644
--- a/http2/http2_structures.cc
+++ b/http2/http2_structures.cc

@@ -130,4 +130,22 @@
   return out << "origin_length=" << v.origin_length;
 }
 
+// Http2PriorityUpdateFields:
+
+bool operator==(const Http2PriorityUpdateFields& a,
+                const Http2PriorityUpdateFields& b) {
+  return a.prioritized_stream_id == b.prioritized_stream_id;
+}
+
+std::string Http2PriorityUpdateFields::ToString() const {
+  std::stringstream ss;
+  ss << "prioritized_stream_id=" << prioritized_stream_id;
+  return ss.str();
+}
+
+std::ostream& operator<<(std::ostream& out,
+                         const Http2PriorityUpdateFields& v) {
+  return out << v.ToString();
+}
+
 }  // namespace http2

diff --git a/http2/http2_structures.h b/http2/http2_structures.h
index f4b9030..79f739d 100644
--- a/http2/http2_structures.h
+++ b/http2/http2_structures.h

@@ -321,6 +321,32 @@
 QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
                                                const Http2AltSvcFields& v);
 
+// Http2PriorityUpdateFields:
+
+struct QUICHE_EXPORT_PRIVATE Http2PriorityUpdateFields {
+  Http2PriorityUpdateFields() {}
+  Http2PriorityUpdateFields(uint32_t prioritized_stream_id)
+      : prioritized_stream_id(prioritized_stream_id) {}
+  static constexpr size_t EncodedSize() { return 4; }
+
+  // Produce strings useful for debugging/logging messages.
+  std::string ToString() const;
+
+  // The 31-bit stream identifier of the stream whose priority is updated.
+  uint32_t prioritized_stream_id;
+};
+
+QUICHE_EXPORT_PRIVATE bool operator==(const Http2PriorityUpdateFields& a,
+                                      const Http2PriorityUpdateFields& b);
+QUICHE_EXPORT_PRIVATE inline bool operator!=(
+    const Http2PriorityUpdateFields& a,
+    const Http2PriorityUpdateFields& b) {
+  return !(a == b);
+}
+QUICHE_EXPORT_PRIVATE std::ostream& operator<<(
+    std::ostream& out,
+    const Http2PriorityUpdateFields& v);
+
 }  // namespace http2
 
 #endif  // QUICHE_HTTP2_HTTP2_STRUCTURES_H_

diff --git a/http2/http2_structures_test.cc b/http2/http2_structures_test.cc
index b29d4b6..3525c40 100644
--- a/http2/http2_structures_test.cc
+++ b/http2/http2_structures_test.cc

@@ -535,6 +535,27 @@
   EXPECT_TRUE(VerifyRandomCalls<Http2AltSvcFields>());
 }
 
+TEST(Http2PriorityUpdateFieldsTest, Eq) {
+  Http2PriorityUpdateFields u(/* prioritized_stream_id = */ 1);
+  Http2PriorityUpdateFields v(/* prioritized_stream_id = */ 3);
+
+  EXPECT_NE(u, v);
+  EXPECT_FALSE(u == v);
+  EXPECT_TRUE(u != v);
+
+  u = v;
+  EXPECT_EQ(u, v);
+  EXPECT_TRUE(u == v);
+  EXPECT_FALSE(u != v);
+}
+
+TEST(Http2PriorityUpdateFieldsTest, Misc) {
+  Http2PriorityUpdateFields u(/* prioritized_stream_id = */ 1);
+  EXPECT_EQ("prioritized_stream_id=1", u.ToString());
+
+  EXPECT_TRUE(VerifyRandomCalls<Http2PriorityUpdateFields>());
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace http2

diff --git a/http2/http2_structures_test_util.cc b/http2/http2_structures_test_util.cc
index ecdbadc..83b5a95 100644
--- a/http2/http2_structures_test_util.cc
+++ b/http2/http2_structures_test_util.cc

@@ -50,6 +50,9 @@
 void Randomize(Http2AltSvcFields* out, Http2Random* rng) {
   out->origin_length = rng->Rand16();
 }
+void Randomize(Http2PriorityUpdateFields* out, Http2Random* rng) {
+  out->prioritized_stream_id = rng->Rand32() & StreamIdMask();
+}
 
 void ScrubFlagsOfHeader(Http2FrameHeader* header) {
   uint8_t invalid_mask = InvalidFlagMaskForFrameType(header->type);

diff --git a/http2/http2_structures_test_util.h b/http2/http2_structures_test_util.h
index 81bf6bf..31c1f14 100644
--- a/http2/http2_structures_test_util.h
+++ b/http2/http2_structures_test_util.h

@@ -34,6 +34,7 @@
 void Randomize(Http2GoAwayFields* out, Http2Random* rng);
 void Randomize(Http2WindowUpdateFields* out, Http2Random* rng);
 void Randomize(Http2AltSvcFields* out, Http2Random* rng);
+void Randomize(Http2PriorityUpdateFields* out, Http2Random* rng);
 
 // Clear bits of header->flags that are known to be invalid for the
 // type. For unknown frame types, no change is made.

diff --git a/http2/test_tools/frame_parts.cc b/http2/test_tools/frame_parts.cc
index f4fd391..aea23a9 100644
--- a/http2/test_tools/frame_parts.cc
+++ b/http2/test_tools/frame_parts.cc

@@ -84,6 +84,7 @@
 
   VERIFY_OPTIONAL_FIELD(opt_altsvc_origin_length_) << COMMON_MESSAGE;
   VERIFY_OPTIONAL_FIELD(opt_altsvc_value_length_) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_priority_update_) << COMMON_MESSAGE;
   VERIFY_OPTIONAL_FIELD(opt_goaway_) << COMMON_MESSAGE;
   VERIFY_OPTIONAL_FIELD(opt_missing_length_) << COMMON_MESSAGE;
   VERIFY_OPTIONAL_FIELD(opt_pad_length_) << COMMON_MESSAGE;
@@ -364,6 +365,31 @@
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::ALTSVC)) << *this;
 }
 
+void FrameParts::OnPriorityUpdateStart(
+    const Http2FrameHeader& header,
+    const Http2PriorityUpdateFields& priority_update) {
+  HTTP2_VLOG(1) << "OnPriorityUpdateStart: " << header
+                << "    prioritized_stream_id: "
+                << priority_update.prioritized_stream_id;
+  ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::PRIORITY_UPDATE))
+      << *this;
+  ASSERT_FALSE(opt_priority_update_);
+  opt_priority_update_ = priority_update;
+  opt_payload_length_ =
+      header.payload_length - Http2PriorityUpdateFields::EncodedSize();
+}
+
+void FrameParts::OnPriorityUpdatePayload(const char* data, size_t len) {
+  HTTP2_VLOG(1) << "OnPriorityUpdatePayload: len=" << len;
+  ASSERT_TRUE(InFrameOfType(Http2FrameType::PRIORITY_UPDATE)) << *this;
+  payload_.append(absl::string_view(data, len));
+}
+
+void FrameParts::OnPriorityUpdateEnd() {
+  HTTP2_VLOG(1) << "OnPriorityUpdateEnd; frame_header_: " << frame_header_;
+  ASSERT_TRUE(EndFrameOfType(Http2FrameType::PRIORITY_UPDATE)) << *this;
+}
+
 void FrameParts::OnUnknownStart(const Http2FrameHeader& header) {
   HTTP2_VLOG(1) << "OnUnknownStart: " << header;
   ASSERT_FALSE(IsSupportedHttp2FrameType(header.type)) << header;
@@ -460,6 +486,9 @@
   if (opt_altsvc_value_length_) {
     out << "  value_length=" << opt_altsvc_value_length_.value() << "\n";
   }
+  if (opt_priority_update_) {
+    out << "  prioritized_stream_id_=" << opt_priority_update_.value() << "\n";
+  }
   if (has_frame_size_error_) {
     out << "  has_frame_size_error\n";
   }

diff --git a/http2/test_tools/frame_parts.h b/http2/test_tools/frame_parts.h
index 9e34fb9..1cc6928 100644
--- a/http2/test_tools/frame_parts.h
+++ b/http2/test_tools/frame_parts.h

@@ -101,6 +101,11 @@
   void OnAltSvcOriginData(const char* data, size_t len) override;
   void OnAltSvcValueData(const char* data, size_t len) override;
   void OnAltSvcEnd() override;
+  void OnPriorityUpdateStart(
+      const Http2FrameHeader& header,
+      const Http2PriorityUpdateFields& priority_update) override;
+  void OnPriorityUpdatePayload(const char* data, size_t len) override;
+  void OnPriorityUpdateEnd() override;
   void OnUnknownStart(const Http2FrameHeader& header) override;
   void OnUnknownPayload(const char* data, size_t len) override;
   void OnUnknownEnd() override;
@@ -180,6 +185,10 @@
       absl::optional<size_t> opt_window_update_increment) {
     opt_window_update_increment_ = opt_window_update_increment;
   }
+  void SetOptPriorityUpdate(
+      absl::optional<Http2PriorityUpdateFields> priority_update) {
+    opt_priority_update_ = priority_update;
+  }
 
   void SetHasFrameSizeError(bool has_frame_size_error) {
     has_frame_size_error_ = has_frame_size_error;
@@ -223,6 +232,7 @@
   absl::optional<Http2PushPromiseFields> opt_push_promise_;
   absl::optional<Http2PingFields> opt_ping_;
   absl::optional<Http2GoAwayFields> opt_goaway_;
+  absl::optional<Http2PriorityUpdateFields> opt_priority_update_;
 
   absl::optional<size_t> opt_pad_length_;
   absl::optional<size_t> opt_payload_length_;

diff --git a/http2/test_tools/frame_parts_collector_listener.cc b/http2/test_tools/frame_parts_collector_listener.cc
index 4326f04..b185d8e 100644
--- a/http2/test_tools/frame_parts_collector_listener.cc
+++ b/http2/test_tools/frame_parts_collector_listener.cc

@@ -196,6 +196,25 @@
   EndFrame()->OnAltSvcEnd();
 }
 
+void FramePartsCollectorListener::OnPriorityUpdateStart(
+    const Http2FrameHeader& header,
+    const Http2PriorityUpdateFields& priority_update) {
+  HTTP2_VLOG(1) << "OnPriorityUpdateStart header: " << header
+                << "; priority_update=" << priority_update;
+  StartFrame(header)->OnPriorityUpdateStart(header, priority_update);
+}
+
+void FramePartsCollectorListener::OnPriorityUpdatePayload(const char* data,
+                                                          size_t len) {
+  HTTP2_VLOG(1) << "OnPriorityUpdatePayload: len=" << len;
+  CurrentFrame()->OnPriorityUpdatePayload(data, len);
+}
+
+void FramePartsCollectorListener::OnPriorityUpdateEnd() {
+  HTTP2_VLOG(1) << "OnPriorityUpdateEnd";
+  EndFrame()->OnPriorityUpdateEnd();
+}
+
 void FramePartsCollectorListener::OnUnknownStart(
     const Http2FrameHeader& header) {
   HTTP2_VLOG(1) << "OnUnknownStart: " << header;

diff --git a/http2/test_tools/frame_parts_collector_listener.h b/http2/test_tools/frame_parts_collector_listener.h
index 84792ac..bb09bf8 100644
--- a/http2/test_tools/frame_parts_collector_listener.h
+++ b/http2/test_tools/frame_parts_collector_listener.h

@@ -71,6 +71,11 @@
   void OnAltSvcOriginData(const char* data, size_t len) override;
   void OnAltSvcValueData(const char* data, size_t len) override;
   void OnAltSvcEnd() override;
+  void OnPriorityUpdateStart(
+      const Http2FrameHeader& header,
+      const Http2PriorityUpdateFields& priority_update) override;
+  void OnPriorityUpdatePayload(const char* data, size_t len) override;
+  void OnPriorityUpdateEnd() override;
   void OnUnknownStart(const Http2FrameHeader& header) override;
   void OnUnknownPayload(const char* data, size_t len) override;
   void OnUnknownEnd() override;

diff --git a/http2/tools/http2_frame_builder.cc b/http2/tools/http2_frame_builder.cc
index 9bb79e1..d6cd110 100644
--- a/http2/tools/http2_frame_builder.cc
+++ b/http2/tools/http2_frame_builder.cc

@@ -141,6 +141,10 @@
   AppendUInt16(v.origin_length);
 }
 
+void Http2FrameBuilder::Append(const Http2PriorityUpdateFields& v) {
+  AppendUInt31(v.prioritized_stream_id);
+}
+
 // Methods for changing existing buffer contents.
 
 void Http2FrameBuilder::WriteAt(absl::string_view s, size_t offset) {

diff --git a/http2/tools/http2_frame_builder.h b/http2/tools/http2_frame_builder.h
index 2ed37d5..a40e46d 100644
--- a/http2/tools/http2_frame_builder.h
+++ b/http2/tools/http2_frame_builder.h

@@ -76,6 +76,7 @@
   void Append(const Http2GoAwayFields& v);
   void Append(const Http2WindowUpdateFields& v);
   void Append(const Http2AltSvcFields& v);
+  void Append(const Http2PriorityUpdateFields& v);
 
   // Methods for changing existing buffer contents (mostly focused on updating
   // the payload length).

diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index baf8ee9..0e149b1 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h

@@ -69,6 +69,7 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_write_or_buffer_data_at_level, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_send_quic_fallback_server_config_on_leto_error, false)
 QUIC_FLAG(FLAGS_quic_restart_flag_dont_fetch_quic_private_keys_from_leto, false)
+QUIC_FLAG(FLAGS_quic_restart_flag_http2_parse_priority_update_frame, false)
 QUIC_FLAG(FLAGS_quic_restart_flag_quic_dispatcher_support_multiple_cid_per_connection, false)
 QUIC_FLAG(FLAGS_quic_restart_flag_quic_enable_zero_rtt_for_tls_v2, true)
 QUIC_FLAG(FLAGS_quic_restart_flag_quic_offload_pacing_to_usps2, false)

diff --git a/spdy/core/http2_frame_decoder_adapter.cc b/spdy/core/http2_frame_decoder_adapter.cc
index 379d221..376c3c1 100644
--- a/spdy/core/http2_frame_decoder_adapter.cc
+++ b/spdy/core/http2_frame_decoder_adapter.cc

@@ -717,6 +717,33 @@
   alt_svc_value_.shrink_to_fit();
 }
 
+void Http2DecoderAdapter::OnPriorityUpdateStart(
+    const Http2FrameHeader& header,
+    const Http2PriorityUpdateFields& priority_update) {
+  SPDY_DVLOG(1) << "OnPriorityUpdateStart: " << header
+                << "; prioritized_stream_id: "
+                << priority_update.prioritized_stream_id;
+  if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header) &&
+      HasRequiredStreamId(priority_update.prioritized_stream_id)) {
+    frame_header_ = header;
+    has_frame_header_ = true;
+    prioritized_stream_id_ = priority_update.prioritized_stream_id;
+  }
+}
+
+void Http2DecoderAdapter::OnPriorityUpdatePayload(const char* data,
+                                                  size_t len) {
+  SPDY_DVLOG(1) << "OnPriorityUpdatePayload: len=" << len;
+  priority_field_value_.append(data, len);
+}
+
+void Http2DecoderAdapter::OnPriorityUpdateEnd() {
+  SPDY_DVLOG(1) << "OnPriorityUpdateEnd: priority_field_value.size(): "
+                << priority_field_value_.size();
+  visitor()->OnPriorityUpdate(prioritized_stream_id_, priority_field_value_);
+  priority_field_value_.clear();
+}
+
 // Except for BLOCKED frames, all other unknown frames are either dropped or
 // passed to a registered extension.
 void Http2DecoderAdapter::OnUnknownStart(const Http2FrameHeader& header) {

diff --git a/spdy/core/http2_frame_decoder_adapter.h b/spdy/core/http2_frame_decoder_adapter.h
index 1192bba..44f3800 100644
--- a/spdy/core/http2_frame_decoder_adapter.h
+++ b/spdy/core/http2_frame_decoder_adapter.h

@@ -209,6 +209,11 @@
   void OnAltSvcOriginData(const char* data, size_t len) override;
   void OnAltSvcValueData(const char* data, size_t len) override;
   void OnAltSvcEnd() override;
+  void OnPriorityUpdateStart(
+      const Http2FrameHeader& header,
+      const Http2PriorityUpdateFields& priority_update) override;
+  void OnPriorityUpdatePayload(const char* data, size_t len) override;
+  void OnPriorityUpdateEnd() override;
   void OnUnknownStart(const Http2FrameHeader& header) override;
   void OnUnknownPayload(const char* data, size_t len) override;
   void OnUnknownEnd() override;
@@ -275,6 +280,10 @@
   std::string alt_svc_origin_;
   std::string alt_svc_value_;
 
+  // Temporary buffers for PRIORITY_UPDATE fields.
+  uint32_t prioritized_stream_id_ = 0;
+  std::string priority_field_value_;
+
   // Listener used if we transition to an error state; the listener ignores all
   // the callbacks.
   Http2FrameDecoderNoOpListener no_op_listener_;

diff --git a/spdy/core/spdy_framer_test.cc b/spdy/core/spdy_framer_test.cc
index 6310e32..3da8dbc 100644
--- a/spdy/core/spdy_framer_test.cc
+++ b/spdy/core/spdy_framer_test.cc

@@ -4517,6 +4517,149 @@
              deframer_.spdy_framer_error());
 }
 
+TEST_P(SpdyFramerTest, ReadPriorityUpdateFrame) {
+  const char kFrameData[] = {
+      0x00, 0x00, 0x07,        // payload length
+      0x10,                    // frame type PRIORITY_UPDATE
+      0x00,                    // flags
+      0x00, 0x00, 0x00, 0x00,  // stream ID, must be 0
+      0x00, 0x00, 0x00, 0x03,  // prioritized stream ID, must not be zero
+      'f',  'o',  'o'          // priority field value
+  };
+
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  deframer_.set_visitor(&visitor);
+
+  if (GetHttp2RestartFlag(http2_parse_priority_update_frame)) {
+    EXPECT_CALL(visitor, OnPriorityUpdate(3, "foo"));
+  } else {
+    EXPECT_CALL(visitor, OnUnknownFrame(0, _)).WillOnce(testing::Return(true));
+  }
+
+  deframer_.ProcessInput(kFrameData, sizeof(kFrameData));
+  EXPECT_FALSE(deframer_.HasError());
+}
+
+TEST_P(SpdyFramerTest, ReadPriorityUpdateFrameWithEmptyPriorityFieldValue) {
+  const char kFrameData[] = {
+      0x00, 0x00, 0x04,        // payload length
+      0x10,                    // frame type PRIORITY_UPDATE
+      0x00,                    // flags
+      0x00, 0x00, 0x00, 0x00,  // stream ID, must be 0
+      0x00, 0x00, 0x00, 0x03   // prioritized stream ID, must not be zero
+  };
+
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  deframer_.set_visitor(&visitor);
+
+  if (GetHttp2RestartFlag(http2_parse_priority_update_frame)) {
+    EXPECT_CALL(visitor, OnPriorityUpdate(3, ""));
+  } else {
+    EXPECT_CALL(visitor, OnUnknownFrame(0, _)).WillOnce(testing::Return(true));
+  }
+
+  deframer_.ProcessInput(kFrameData, sizeof(kFrameData));
+  EXPECT_FALSE(deframer_.HasError());
+}
+
+TEST_P(SpdyFramerTest, PriorityUpdateFrameWithEmptyPayload) {
+  const char kFrameData[] = {
+      0x00, 0x00, 0x00,        // payload length
+      0x10,                    // frame type PRIORITY_UPDATE
+      0x00,                    // flags
+      0x00, 0x00, 0x00, 0x00,  // stream ID, must be 0
+  };
+
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  deframer_.set_visitor(&visitor);
+
+  if (GetHttp2RestartFlag(http2_parse_priority_update_frame)) {
+    EXPECT_CALL(
+        visitor,
+        OnError(Http2DecoderAdapter::SPDY_INVALID_CONTROL_FRAME_SIZE, _));
+    deframer_.ProcessInput(kFrameData, sizeof(kFrameData));
+    EXPECT_TRUE(deframer_.HasError());
+  } else {
+    EXPECT_CALL(visitor, OnUnknownFrame(0, _)).WillOnce(testing::Return(true));
+    deframer_.ProcessInput(kFrameData, sizeof(kFrameData));
+    EXPECT_FALSE(deframer_.HasError());
+  }
+}
+
+TEST_P(SpdyFramerTest, PriorityUpdateFrameWithShortPayload) {
+  const char kFrameData[] = {
+      0x00, 0x00, 0x02,        // payload length
+      0x10,                    // frame type PRIORITY_UPDATE
+      0x00,                    // flags
+      0x00, 0x00, 0x00, 0x00,  // stream ID, must be 0
+      0x00, 0x01  // payload not long enough to hold 32 bits of prioritized
+                  // stream ID
+  };
+
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  deframer_.set_visitor(&visitor);
+
+  if (GetHttp2RestartFlag(http2_parse_priority_update_frame)) {
+    EXPECT_CALL(
+        visitor,
+        OnError(Http2DecoderAdapter::SPDY_INVALID_CONTROL_FRAME_SIZE, _));
+    deframer_.ProcessInput(kFrameData, sizeof(kFrameData));
+    EXPECT_TRUE(deframer_.HasError());
+  } else {
+    EXPECT_CALL(visitor, OnUnknownFrame(0, _)).WillOnce(testing::Return(true));
+    deframer_.ProcessInput(kFrameData, sizeof(kFrameData));
+    EXPECT_FALSE(deframer_.HasError());
+  }
+}
+
+TEST_P(SpdyFramerTest, PriorityUpdateFrameOnIncorrectStream) {
+  const char kFrameData[] = {
+      0x00, 0x00, 0x04,        // payload length
+      0x10,                    // frame type PRIORITY_UPDATE
+      0x00,                    // flags
+      0x00, 0x00, 0x00, 0x01,  // invalid stream ID, must be 0
+      0x00, 0x00, 0x00, 0x01,  // prioritized stream ID, must not be zero
+  };
+
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  deframer_.set_visitor(&visitor);
+
+  if (GetHttp2RestartFlag(http2_parse_priority_update_frame)) {
+    EXPECT_CALL(visitor,
+                OnError(Http2DecoderAdapter::SPDY_INVALID_STREAM_ID, _));
+    deframer_.ProcessInput(kFrameData, sizeof(kFrameData));
+    EXPECT_TRUE(deframer_.HasError());
+  } else {
+    EXPECT_CALL(visitor, OnUnknownFrame(1, _)).WillOnce(testing::Return(true));
+    deframer_.ProcessInput(kFrameData, sizeof(kFrameData));
+    EXPECT_FALSE(deframer_.HasError());
+  }
+}
+
+TEST_P(SpdyFramerTest, PriorityUpdateFramePrioritizingIncorrectStream) {
+  const char kFrameData[] = {
+      0x00, 0x00, 0x04,        // payload length
+      0x10,                    // frame type PRIORITY_UPDATE
+      0x00,                    // flags
+      0x00, 0x00, 0x00, 0x00,  // stream ID, must be 0
+      0x00, 0x00, 0x00, 0x00,  // prioritized stream ID, must not be zero
+  };
+
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  deframer_.set_visitor(&visitor);
+
+  if (GetHttp2RestartFlag(http2_parse_priority_update_frame)) {
+    EXPECT_CALL(visitor,
+                OnError(Http2DecoderAdapter::SPDY_INVALID_STREAM_ID, _));
+    deframer_.ProcessInput(kFrameData, sizeof(kFrameData));
+    EXPECT_TRUE(deframer_.HasError());
+  } else {
+    EXPECT_CALL(visitor, OnUnknownFrame(0, _)).WillOnce(testing::Return(true));
+    deframer_.ProcessInput(kFrameData, sizeof(kFrameData));
+    EXPECT_FALSE(deframer_.HasError());
+  }
+}
+
 // Tests handling of PRIORITY frames.
 TEST_P(SpdyFramerTest, ReadPriority) {
   SpdyPriorityIR priority(/* stream_id = */ 3,