@fails-components/webtransport 0.0.1-rc.0 → 0.0.1-rc.1

package/third_party/quiche/quiche/http2/adapter/event_forwarder_test.cc

@@ -89,11 +89,12 @@ TEST(EventForwarderTest, ForwardsEventsWithTruePredicate) {
   EXPECT_CALL(receiver, OnGoAwayFrameData(some_data.data(), some_data.size()));
   event_forwarder.OnGoAwayFrameData(some_data.data(), some_data.size());
 
-  EXPECT_CALL(
-      receiver,
-      OnHeaders(stream_id, /*has_priority=*/false, /*weight=*/42, stream_id + 2,
-                /*exclusive=*/false, /*fin=*/true, /*end=*/true));
-  event_forwarder.OnHeaders(stream_id, /*has_priority=*/false, /*weight=*/42,
+  EXPECT_CALL(receiver,
+              OnHeaders(stream_id, /*payload_length=*/1234,
+                        /*has_priority=*/false, /*weight=*/42, stream_id + 2,
+                        /*exclusive=*/false, /*fin=*/true, /*end=*/true));
+  event_forwarder.OnHeaders(stream_id, /*payload_length=*/1234,
+                            /*has_priority=*/false, /*weight=*/42,
                             stream_id + 2, /*exclusive=*/false, /*fin=*/true,
                             /*end=*/true);
 
@@ -103,8 +104,10 @@ TEST(EventForwarderTest, ForwardsEventsWithTruePredicate) {
   EXPECT_CALL(receiver, OnPushPromise(stream_id, stream_id + 1, /*end=*/true));
   event_forwarder.OnPushPromise(stream_id, stream_id + 1, /*end=*/true);
 
-  EXPECT_CALL(receiver, OnContinuation(stream_id, /*end=*/true));
-  event_forwarder.OnContinuation(stream_id, /*end=*/true);
+  EXPECT_CALL(receiver,
+              OnContinuation(stream_id, /*payload_length=*/42, /*end=*/true));
+  event_forwarder.OnContinuation(stream_id, /*payload_length=*/42,
+                                 /*end=*/true);
 
   const spdy::SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   EXPECT_CALL(receiver, OnAltSvc(stream_id, some_data, altsvc_vector));
@@ -186,7 +189,8 @@ TEST(EventForwarderTest, DoesNotForwardEventsWithFalsePredicate) {
   event_forwarder.OnGoAwayFrameData(some_data.data(), some_data.size());
 
   EXPECT_CALL(receiver, OnHeaders).Times(0);
-  event_forwarder.OnHeaders(stream_id, /*has_priority=*/false, /*weight=*/42,
+  event_forwarder.OnHeaders(stream_id, /*payload_length=*/1234,
+                            /*has_priority=*/false, /*weight=*/42,
                             stream_id + 2, /*exclusive=*/false, /*fin=*/true,
                             /*end=*/true);
 
@@ -197,7 +201,8 @@ TEST(EventForwarderTest, DoesNotForwardEventsWithFalsePredicate) {
   event_forwarder.OnPushPromise(stream_id, stream_id + 1, /*end=*/true);
 
   EXPECT_CALL(receiver, OnContinuation).Times(0);
-  event_forwarder.OnContinuation(stream_id, /*end=*/true);
+  event_forwarder.OnContinuation(stream_id, /*payload_length=*/42,
+                                 /*end=*/true);
 
   EXPECT_CALL(receiver, OnAltSvc).Times(0);
   const spdy::SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;

package/third_party/quiche/quiche/http2/adapter/header_validator.cc

@@ -81,17 +81,30 @@ bool IsValidStatus(absl::string_view status) {
 }
 
 bool ValidateRequestHeaders(const std::vector<std::string>& pseudo_headers,
+                            absl::optional<std::string>& authority,
                             absl::string_view method, absl::string_view path,
-                            bool allow_connect) {
+                            bool allow_extended_connect) {
   QUICHE_VLOG(2) << "Request pseudo-headers: ["
                  << absl::StrJoin(pseudo_headers, ", ")
-                 << "], allow_connect: " << allow_connect
+                 << "], allow_extended_connect: " << allow_extended_connect
+                 << ", authority: "
+                 << (authority ? authority.value() : "<nullopt>")
                  << ", method: " << method << ", path: " << path;
-  if (allow_connect && method == "CONNECT") {
+  if (method == "CONNECT") {
+    if (allow_extended_connect) {
+      // See RFC 8441.
+      static const std::vector<std::string>* kExtendedConnectHeaders =
+          new std::vector<std::string>(
+              {":authority", ":method", ":path", ":protocol", ":scheme"});
+      if (pseudo_headers == *kExtendedConnectHeaders) {
+        return true;
+      }
+    }
+    // See RFC 7540 Section 8.3.
     static const std::vector<std::string>* kConnectHeaders =
-        new std::vector<std::string>(
-            {":authority", ":method", ":path", ":protocol", ":scheme"});
-    return pseudo_headers == *kConnectHeaders;
+        new std::vector<std::string>({":authority", ":method"});
+    return authority.has_value() && !authority.value().empty() &&
+           pseudo_headers == *kConnectHeaders;
   }
 
   if (path.empty()) {
@@ -128,12 +141,11 @@ bool ValidateResponseTrailers(const std::vector<std::string>& pseudo_headers) {
 }  // namespace
 
 void HeaderValidator::StartHeaderBlock() {
+  HeaderValidatorBase::StartHeaderBlock();
   pseudo_headers_.clear();
-  status_.clear();
   method_.clear();
   path_.clear();
   authority_ = absl::nullopt;
-  content_length_.reset();
 }
 
 HeaderValidator::HeaderStatus HeaderValidator::ValidateSingleHeader(
@@ -194,9 +206,16 @@ HeaderValidator::HeaderStatus HeaderValidator::ValidateSingleHeader(
       }
     }
   } else if (key == "content-length") {
-    const bool success = HandleContentLength(value);
-    if (!success) {
-      return HEADER_FIELD_INVALID;
+    const ContentLengthStatus status = HandleContentLength(value);
+    switch (status) {
+      case CONTENT_LENGTH_ERROR:
+        return HEADER_FIELD_INVALID;
+      case CONTENT_LENGTH_SKIP:
+        return HEADER_SKIP;
+      case CONTENT_LENGTH_OK:
+        return HEADER_OK;
+      default:
+        return HEADER_FIELD_INVALID;
     }
   } else if (key == "te" && value != "trailers") {
     return HEADER_FIELD_INVALID;
@@ -214,8 +233,8 @@ bool HeaderValidator::FinishHeaderBlock(HeaderType type) {
   std::sort(pseudo_headers_.begin(), pseudo_headers_.end());
   switch (type) {
     case HeaderType::REQUEST:
-      return ValidateRequestHeaders(pseudo_headers_, method_, path_,
-                                    allow_connect_);
+      return ValidateRequestHeaders(pseudo_headers_, authority_, method_, path_,
+                                    allow_extended_connect_);
     case HeaderType::REQUEST_TRAILER:
       return ValidateRequestTrailers(pseudo_headers_);
     case HeaderType::RESPONSE_100:
@@ -227,28 +246,33 @@ bool HeaderValidator::FinishHeaderBlock(HeaderType type) {
   return false;
 }
 
-bool HeaderValidator::HandleContentLength(absl::string_view value) {
+HeaderValidator::ContentLengthStatus HeaderValidator::HandleContentLength(
+    absl::string_view value) {
   if (value.empty()) {
-    return false;
+    return CONTENT_LENGTH_ERROR;
   }
 
   if (status_ == "204" && value != "0") {
     // There should be no body in a "204 No Content" response.
-    return false;
+    return CONTENT_LENGTH_ERROR;
   }
   if (!status_.empty() && status_[0] == '1' && value != "0") {
     // There should also be no body in a 1xx response.
-    return false;
+    return CONTENT_LENGTH_ERROR;
   }
 
   size_t content_length = 0;
   const bool valid = absl::SimpleAtoi(value, &content_length);
   if (!valid) {
-    return false;
+    return CONTENT_LENGTH_ERROR;
   }
 
+  if (content_length_.has_value()) {
+    return content_length == content_length_.value() ? CONTENT_LENGTH_SKIP
+                                                     : CONTENT_LENGTH_ERROR;
+  }
   content_length_ = content_length;
-  return true;
+  return CONTENT_LENGTH_OK;
 }
 
 // Returns whether `authority` contains only characters from the `host` ABNF

package/third_party/quiche/quiche/http2/adapter/header_validator.h

@@ -6,67 +6,38 @@
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "quiche/http2/adapter/header_validator_base.h"
 #include "quiche/common/platform/api/quiche_export.h"
 
 namespace http2 {
 namespace adapter {
 
-enum class HeaderType : uint8_t {
-  REQUEST,
-  REQUEST_TRAILER,
-  RESPONSE_100,
-  RESPONSE,
-  RESPONSE_TRAILER,
-};
-
-enum class ObsTextOption : uint8_t {
-  kAllow,
-  kDisallow,
-};
-
-class QUICHE_EXPORT_PRIVATE HeaderValidator {
+class QUICHE_EXPORT_PRIVATE HeaderValidator : public HeaderValidatorBase {
  public:
   HeaderValidator() = default;
 
-  void SetMaxFieldSize(uint32_t field_size) { max_field_size_ = field_size; }
-  void SetObsTextOption(ObsTextOption option) { obs_text_option_ = option; }
-
-  // If called, this validator will allow the `:protocol` pseudo-header, as
-  // described in RFC 8441.
-  void AllowConnect() { allow_connect_ = true; }
+  void StartHeaderBlock() override;
 
-  void StartHeaderBlock();
-
-  enum HeaderStatus {
-    HEADER_OK,
-    HEADER_FIELD_INVALID,
-    HEADER_FIELD_TOO_LONG,
-  };
   HeaderStatus ValidateSingleHeader(absl::string_view key,
-                                    absl::string_view value);
+                                    absl::string_view value) override;
 
   // Returns true if all required pseudoheaders and no extra pseudoheaders are
   // present for the given header type.
-  bool FinishHeaderBlock(HeaderType type);
-
-  // For responses, returns the value of the ":status" header, if present.
-  absl::string_view status_header() const { return status_; }
-
-  absl::optional<size_t> content_length() const { return content_length_; }
+  bool FinishHeaderBlock(HeaderType type) override;
 
  private:
-  bool HandleContentLength(absl::string_view value);
+  enum ContentLengthStatus {
+    CONTENT_LENGTH_OK,
+    CONTENT_LENGTH_SKIP,  // Used to handle duplicate content length values.
+    CONTENT_LENGTH_ERROR,
+  };
+  ContentLengthStatus HandleContentLength(absl::string_view value);
   bool ValidateAndSetAuthority(absl::string_view authority);
 
   std::vector<std::string> pseudo_headers_;
   absl::optional<std::string> authority_ = absl::nullopt;
-  std::string status_;
   std::string method_;
   std::string path_;
-  absl::optional<size_t> max_field_size_;
-  absl::optional<size_t> content_length_;
-  ObsTextOption obs_text_option_ = ObsTextOption::kDisallow;
-  bool allow_connect_ = false;
 };
 
 }  // namespace adapter

package/third_party/quiche/quiche/http2/adapter/header_validator_base.h

@@ -0,0 +1,69 @@
+#ifndef QUICHE_HTTP2_ADAPTER_HEADER_VALIDATOR_BASE_H_
+#define QUICHE_HTTP2_ADAPTER_HEADER_VALIDATOR_BASE_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace http2 {
+namespace adapter {
+
+enum class HeaderType : uint8_t {
+  REQUEST,
+  REQUEST_TRAILER,
+  RESPONSE_100,
+  RESPONSE,
+  RESPONSE_TRAILER,
+};
+
+enum class ObsTextOption : uint8_t {
+  kAllow,
+  kDisallow,
+};
+
+class QUICHE_EXPORT_PRIVATE HeaderValidatorBase {
+ public:
+  HeaderValidatorBase() = default;
+  virtual ~HeaderValidatorBase() = default;
+
+  virtual void StartHeaderBlock() {
+    status_.clear();
+    content_length_ = absl::nullopt;
+  }
+
+  enum HeaderStatus {
+    HEADER_OK,
+    HEADER_SKIP,
+    HEADER_FIELD_INVALID,
+    HEADER_FIELD_TOO_LONG,
+  };
+  virtual HeaderStatus ValidateSingleHeader(absl::string_view key,
+                                            absl::string_view value) = 0;
+
+  // Should return true if validation was successful.
+  virtual bool FinishHeaderBlock(HeaderType type) = 0;
+
+  // For responses, returns the value of the ":status" header, if present.
+  absl::string_view status_header() const { return status_; }
+
+  absl::optional<size_t> content_length() const { return content_length_; }
+
+  void SetMaxFieldSize(uint32_t field_size) { max_field_size_ = field_size; }
+  void SetObsTextOption(ObsTextOption option) { obs_text_option_ = option; }
+  // Allows the "extended CONNECT" syntax described in RFC 8441.
+  void SetAllowExtendedConnect() { allow_extended_connect_ = true; }
+
+ protected:
+  std::string status_;
+  absl::optional<size_t> max_field_size_;
+  absl::optional<size_t> content_length_;
+  ObsTextOption obs_text_option_ = ObsTextOption::kDisallow;
+  bool allow_extended_connect_ = false;
+};
+
+}  // namespace adapter
+}  // namespace http2
+
+#endif  // QUICHE_HTTP2_ADAPTER_HEADER_VALIDATOR_BASE_H_

package/third_party/quiche/quiche/http2/adapter/header_validator_test.cc

@@ -266,6 +266,54 @@ TEST(HeaderValidatorTest, RequestPseudoHeaders) {
   }
 }
 
+TEST(HeaderValidatorTest, ConnectHeaders) {
+  // Too few headers.
+  HeaderValidator v;
+  v.StartHeaderBlock();
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":authority", "athena.dialup.mit.edu:23"));
+  EXPECT_FALSE(v.FinishHeaderBlock(HeaderType::REQUEST));
+
+  v.StartHeaderBlock();
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":method", "CONNECT"));
+  EXPECT_FALSE(v.FinishHeaderBlock(HeaderType::REQUEST));
+
+  // Too many headers.
+  v.StartHeaderBlock();
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":authority", "athena.dialup.mit.edu:23"));
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":method", "CONNECT"));
+  EXPECT_EQ(HeaderValidator::HEADER_OK, v.ValidateSingleHeader(":path", "/"));
+  EXPECT_FALSE(v.FinishHeaderBlock(HeaderType::REQUEST));
+
+  // Empty :authority
+  v.StartHeaderBlock();
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":authority", ""));
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":method", "CONNECT"));
+  EXPECT_FALSE(v.FinishHeaderBlock(HeaderType::REQUEST));
+
+  // Just right.
+  v.StartHeaderBlock();
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":authority", "athena.dialup.mit.edu:23"));
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":method", "CONNECT"));
+  EXPECT_TRUE(v.FinishHeaderBlock(HeaderType::REQUEST));
+
+  v.SetAllowExtendedConnect();
+  // "Classic" CONNECT headers should still be accepted.
+  v.StartHeaderBlock();
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":authority", "athena.dialup.mit.edu:23"));
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":method", "CONNECT"));
+  EXPECT_TRUE(v.FinishHeaderBlock(HeaderType::REQUEST));
+}
+
 TEST(HeaderValidatorTest, WebsocketPseudoHeaders) {
   HeaderValidator v;
   v.StartHeaderBlock();
@@ -280,7 +328,7 @@ TEST(HeaderValidatorTest, WebsocketPseudoHeaders) {
 
   // Future header blocks may send the `:protocol` pseudo-header for CONNECT
   // requests.
-  v.AllowConnect();
+  v.SetAllowExtendedConnect();
 
   v.StartHeaderBlock();
   for (Header to_add : kSampleRequestPseudoheaders) {
@@ -428,6 +476,30 @@ TEST(HeaderValidatorTest, Response204) {
   EXPECT_TRUE(v.FinishHeaderBlock(HeaderType::RESPONSE));
 }
 
+TEST(HeaderValidatorTest, ResponseWithMultipleIdenticalContentLength) {
+  HeaderValidator v;
+
+  v.StartHeaderBlock();
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":status", "200"));
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader("content-length", "13"));
+  EXPECT_EQ(HeaderValidator::HEADER_SKIP,
+            v.ValidateSingleHeader("content-length", "13"));
+}
+
+TEST(HeaderValidatorTest, ResponseWithMultipleDifferingContentLength) {
+  HeaderValidator v;
+
+  v.StartHeaderBlock();
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader(":status", "200"));
+  EXPECT_EQ(HeaderValidator::HEADER_OK,
+            v.ValidateSingleHeader("content-length", "13"));
+  EXPECT_EQ(HeaderValidator::HEADER_FIELD_INVALID,
+            v.ValidateSingleHeader("content-length", "17"));
+}
+
 TEST(HeaderValidatorTest, Response204WithContentLengthZero) {
   HeaderValidator v;
 

package/third_party/quiche/quiche/http2/adapter/nghttp2_adapter_test.cc

@@ -5281,6 +5281,72 @@ TEST(NgHttp2AdapterTest, IncompleteRequestWithServerResponse) {
   EXPECT_FALSE(adapter->want_write());
 }
 
+TEST(NgHttp2AdapterTest, ServerHandlesMultipleContentLength) {
+  DataSavingVisitor visitor;
+  auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);
+  EXPECT_FALSE(adapter->want_write());
+
+  const std::string frames = TestFrameSequence()
+                                 .ClientPreface()
+                                 .Headers(1,
+                                          {{":method", "POST"},
+                                           {":scheme", "https"},
+                                           {":authority", "example.com"},
+                                           {":path", "/1"},
+                                           {"content-length", "7"},
+                                           {"content-length", "7"}},
+                                          /*fin=*/false)
+                                 .Headers(3,
+                                          {{":method", "POST"},
+                                           {":scheme", "https"},
+                                           {":authority", "example.com"},
+                                           {":path", "/3"},
+                                           {"content-length", "11"},
+                                           {"content-length", "13"}},
+                                          /*fin=*/false)
+                                 .Serialize();
+  testing::InSequence s;
+
+  // Client preface (empty SETTINGS)
+  EXPECT_CALL(visitor, OnFrameHeader(0, 0, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  EXPECT_CALL(visitor, OnSettingsEnd());
+  // Stream 1
+  EXPECT_CALL(visitor, OnFrameHeader(1, _, HEADERS, 4));
+  EXPECT_CALL(visitor, OnBeginHeadersForStream(1));
+  EXPECT_CALL(visitor, OnHeaderForStream(1, ":method", "POST"));
+  EXPECT_CALL(visitor, OnHeaderForStream(1, ":scheme", "https"));
+  EXPECT_CALL(visitor, OnHeaderForStream(1, ":authority", "example.com"));
+  EXPECT_CALL(visitor, OnHeaderForStream(1, ":path", "/1"));
+  EXPECT_CALL(visitor, OnHeaderForStream(1, "content-length", "7"));
+  // nghttp2 does not like duplicate Content-Length headers.
+  EXPECT_CALL(
+      visitor,
+      OnErrorDebug("Invalid HTTP header field was received: frame type: 1, "
+                   "stream: 1, name: [content-length], value: [7]"));
+  EXPECT_CALL(
+      visitor,
+      OnInvalidFrame(1, Http2VisitorInterface::InvalidFrameError::kHttpHeader));
+  // Stream 3
+  EXPECT_CALL(visitor, OnFrameHeader(3, _, HEADERS, 4));
+  EXPECT_CALL(visitor, OnBeginHeadersForStream(3));
+  EXPECT_CALL(visitor, OnHeaderForStream(3, ":method", "POST"));
+  EXPECT_CALL(visitor, OnHeaderForStream(3, ":scheme", "https"));
+  EXPECT_CALL(visitor, OnHeaderForStream(3, ":authority", "example.com"));
+  EXPECT_CALL(visitor, OnHeaderForStream(3, ":path", "/3"));
+  EXPECT_CALL(visitor, OnHeaderForStream(3, "content-length", "11"));
+  EXPECT_CALL(
+      visitor,
+      OnErrorDebug("Invalid HTTP header field was received: frame type: 1, "
+                   "stream: 3, name: [content-length], value: [13]"));
+  EXPECT_CALL(
+      visitor,
+      OnInvalidFrame(3, Http2VisitorInterface::InvalidFrameError::kHttpHeader));
+
+  const int64_t result = adapter->ProcessBytes(frames);
+  EXPECT_EQ(frames.size(), static_cast<size_t>(result));
+}
+
 TEST(NgHttp2AdapterTest, ServerSendsInvalidTrailers) {
   DataSavingVisitor visitor;
   auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);

package/third_party/quiche/quiche/http2/adapter/nghttp2_session_test.cc

@@ -5,8 +5,8 @@
 #include "quiche/http2/adapter/nghttp2_util.h"
 #include "quiche/http2/adapter/test_frame_sequence.h"
 #include "quiche/http2/adapter/test_utils.h"
+#include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 namespace http2 {
 namespace adapter {
@@ -27,7 +27,7 @@ enum FrameType {
   WINDOW_UPDATE,
 };
 
-class NgHttp2SessionTest : public testing::Test {
+class NgHttp2SessionTest : public quiche::test::QuicheTest {
  public:
   void SetUp() override {
     nghttp2_option_new(&options_);
@@ -311,9 +311,12 @@ TEST_F(NgHttp2SessionTest, NullPayload) {
   ASSERT_EQ(0, result);
   EXPECT_TRUE(session.want_write());
   int send_result = -1;
-  EXPECT_QUICHE_BUG(send_result = nghttp2_session_send(session.raw_ptr()),
-                    "Extension frame payload for stream 1 is null!");
-  EXPECT_EQ(NGHTTP2_ERR_CALLBACK_FAILURE, send_result);
+  EXPECT_QUICHE_BUG(
+      {
+        send_result = nghttp2_session_send(session.raw_ptr());
+        EXPECT_EQ(NGHTTP2_ERR_CALLBACK_FAILURE, send_result);
+      },
+      "Extension frame payload for stream 1 is null!");
 }
 
 }  // namespace

package/third_party/quiche/quiche/http2/adapter/nghttp2_test.cc

@@ -38,7 +38,7 @@ nghttp2_option* GetOptions() {
   return options;
 }
 
-class Nghttp2Test : public testing::Test {
+class Nghttp2Test : public quiche::test::QuicheTest {
  public:
   Nghttp2Test() : session_(MakeSessionPtr(nullptr)) {}
 

package/third_party/quiche/quiche/http2/adapter/noop_header_validator.cc

@@ -0,0 +1,22 @@
+#include "quiche/http2/adapter/noop_header_validator.h"
+
+#include "absl/strings/escaping.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+
+namespace http2 {
+namespace adapter {
+
+HeaderValidatorBase::HeaderStatus NoopHeaderValidator::ValidateSingleHeader(
+    absl::string_view key, absl::string_view value) {
+  if (key == ":status") {
+    status_ = std::string(value);
+  }
+  return HEADER_OK;
+}
+
+bool NoopHeaderValidator::FinishHeaderBlock(HeaderType /* type */) {
+  return true;
+}
+
+}  // namespace adapter
+}  // namespace http2

package/third_party/quiche/quiche/http2/adapter/noop_header_validator.h

@@ -0,0 +1,25 @@
+#ifndef QUICHE_HTTP2_ADAPTER_NOOP_HEADER_VALIDATOR_H_
+#define QUICHE_HTTP2_ADAPTER_NOOP_HEADER_VALIDATOR_H_
+
+#include "absl/strings/string_view.h"
+#include "quiche/http2/adapter/header_validator_base.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace http2 {
+namespace adapter {
+
+// A validator that does not actually perform any validation.
+class QUICHE_EXPORT_PRIVATE NoopHeaderValidator : public HeaderValidatorBase {
+ public:
+  NoopHeaderValidator() = default;
+
+  HeaderStatus ValidateSingleHeader(absl::string_view key,
+                                    absl::string_view value) override;
+
+  bool FinishHeaderBlock(HeaderType type) override;
+};
+
+}  // namespace adapter
+}  // namespace http2
+
+#endif  // QUICHE_HTTP2_ADAPTER_NOOP_HEADER_VALIDATOR_H_