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

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

@@ -9,8 +9,8 @@
 #include "quiche/http2/adapter/oghttp2_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 {
@@ -4531,6 +4531,63 @@ TEST(OgHttp2AdapterTest, IncompleteRequestWithServerResponseRstStreamEnabled) {
   EXPECT_FALSE(adapter->want_write());
 }
 
+TEST(OgHttp2AdapterTest, ServerHandlesMultipleContentLength) {
+  DataSavingVisitor visitor;
+  OgHttp2Adapter::Options options;
+  options.perspective = Perspective::kServer;
+  auto adapter = OgHttp2Adapter::Create(visitor, options);
+  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"));
+  EXPECT_CALL(visitor, OnEndHeadersForStream(1));
+  // 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,
+      OnInvalidFrame(3, Http2VisitorInterface::InvalidFrameError::kHttpHeader));
+
+  const int64_t result = adapter->ProcessBytes(frames);
+  EXPECT_EQ(frames.size(), static_cast<size_t>(result));
+}
+
 TEST(OgHttp2AdapterTest, ServerSendsInvalidTrailers) {
   DataSavingVisitor visitor;
   OgHttp2Adapter::Options options;
@@ -4683,9 +4740,8 @@ TEST(OgHttp2AdapterTest, ServerQueuesMetadataThenTrailers) {
   ASSERT_EQ(trailer_result, 0);
   EXPECT_TRUE(adapter->want_write());
 
-  // BUG! The library forgets to serialize and send the metadata.
-  // EXPECT_CALL(visitor, OnBeforeFrameSent(kMetadataFrameType, 1, _, 0x4));
-  // EXPECT_CALL(visitor, OnFrameSent(kMetadataFrameType, 1, _, 0x4, 0));
+  EXPECT_CALL(visitor, OnBeforeFrameSent(kMetadataFrameType, 1, _, 0x4));
+  EXPECT_CALL(visitor, OnFrameSent(kMetadataFrameType, 1, _, 0x4, 0));
 
   EXPECT_CALL(visitor, OnBeforeFrameSent(HEADERS, 1, _, 0x5));
   EXPECT_CALL(visitor, OnFrameSent(HEADERS, 1, _, 0x5, 0));
@@ -4694,7 +4750,9 @@ TEST(OgHttp2AdapterTest, ServerQueuesMetadataThenTrailers) {
 
   send_result = adapter->Send();
   EXPECT_EQ(0, send_result);
-  EXPECT_THAT(visitor.data(), EqualsFrames({SpdyFrameType::HEADERS}));
+  EXPECT_THAT(visitor.data(),
+              EqualsFrames({static_cast<SpdyFrameType>(kMetadataFrameType),
+                            SpdyFrameType::HEADERS}));
 }
 
 TEST(OgHttp2AdapterTest, ServerHandlesDataWithPadding) {
@@ -7375,6 +7433,129 @@ TEST(OgHttp2AdapterTest, ServerUsesCustomWindowUpdateStrategy) {
                             SpdyFrameType::WINDOW_UPDATE}));
 }
 
+// Verifies that NoopHeaderValidator allows several header combinations that
+// would otherwise be invalid.
+TEST(OgHttp2AdapterTest, NoopHeaderValidatorTest) {
+  DataSavingVisitor visitor;
+  OgHttp2Adapter::Options options;
+  options.perspective = Perspective::kServer;
+  options.validate_http_headers = false;
+  auto adapter = OgHttp2Adapter::Create(visitor, options);
+
+  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)
+                                 .Headers(5,
+                                          {{":method", "POST"},
+                                           {":scheme", "https"},
+                                           {":authority", "foo.com"},
+                                           {":path", "/"},
+                                           {"host", "bar.com"}},
+                                          /*fin=*/true)
+                                 .Headers(7,
+                                          {{":method", "POST"},
+                                           {":scheme", "https"},
+                                           {":authority", "example.com"},
+                                           {":path", "/"},
+                                           {"Accept", "uppercase, oh boy!"}},
+                                          /*fin=*/false)
+                                 .Headers(9,
+                                          {{":method", "POST"},
+                                           {":scheme", "https"},
+                                           {":authority", "ex|ample.com"},
+                                           {":path", "/"}},
+                                          /*fin=*/false)
+                                 .Headers(11,
+                                          {{":method", "GET"},
+                                           {":scheme", "https"},
+                                           {":authority", "example.com"},
+                                           {":path", "/"},
+                                           {"content-length", "nan"}},
+                                          /*fin=*/true)
+                                 .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"));
+  EXPECT_CALL(visitor, OnHeaderForStream(1, "content-length", "7"));
+  EXPECT_CALL(visitor, OnEndHeadersForStream(1));
+  // 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, OnHeaderForStream(3, "content-length", "13"));
+  EXPECT_CALL(visitor, OnEndHeadersForStream(3));
+  // Stream 5
+  EXPECT_CALL(visitor, OnFrameHeader(5, _, HEADERS, 5));
+  EXPECT_CALL(visitor, OnBeginHeadersForStream(5));
+  EXPECT_CALL(visitor, OnHeaderForStream(5, ":method", "POST"));
+  EXPECT_CALL(visitor, OnHeaderForStream(5, ":scheme", "https"));
+  EXPECT_CALL(visitor, OnHeaderForStream(5, ":authority", "foo.com"));
+  EXPECT_CALL(visitor, OnHeaderForStream(5, ":path", "/"));
+  EXPECT_CALL(visitor, OnHeaderForStream(5, "host", "bar.com"));
+  EXPECT_CALL(visitor, OnEndHeadersForStream(5));
+  EXPECT_CALL(visitor, OnEndStream(5));
+  // Stream 7
+  EXPECT_CALL(visitor, OnFrameHeader(7, _, HEADERS, 4));
+  EXPECT_CALL(visitor, OnBeginHeadersForStream(7));
+  EXPECT_CALL(visitor, OnHeaderForStream(7, ":method", "POST"));
+  EXPECT_CALL(visitor, OnHeaderForStream(7, ":scheme", "https"));
+  EXPECT_CALL(visitor, OnHeaderForStream(7, ":authority", "example.com"));
+  EXPECT_CALL(visitor, OnHeaderForStream(7, ":path", "/"));
+  EXPECT_CALL(visitor, OnHeaderForStream(7, "Accept", "uppercase, oh boy!"));
+  EXPECT_CALL(visitor, OnEndHeadersForStream(7));
+  // Stream 9
+  EXPECT_CALL(visitor, OnFrameHeader(9, _, HEADERS, 4));
+  EXPECT_CALL(visitor, OnBeginHeadersForStream(9));
+  EXPECT_CALL(visitor, OnHeaderForStream(9, ":method", "POST"));
+  EXPECT_CALL(visitor, OnHeaderForStream(9, ":scheme", "https"));
+  EXPECT_CALL(visitor, OnHeaderForStream(9, ":authority", "ex|ample.com"));
+  EXPECT_CALL(visitor, OnHeaderForStream(9, ":path", "/"));
+  EXPECT_CALL(visitor, OnEndHeadersForStream(9));
+  // Stream 11
+  EXPECT_CALL(visitor, OnFrameHeader(11, _, HEADERS, 5));
+  EXPECT_CALL(visitor, OnBeginHeadersForStream(11));
+  EXPECT_CALL(visitor, OnHeaderForStream(11, ":method", "GET"));
+  EXPECT_CALL(visitor, OnHeaderForStream(11, ":scheme", "https"));
+  EXPECT_CALL(visitor, OnHeaderForStream(11, ":authority", "example.com"));
+  EXPECT_CALL(visitor, OnHeaderForStream(11, ":path", "/"));
+  EXPECT_CALL(visitor, OnHeaderForStream(11, "content-length", "nan"));
+  EXPECT_CALL(visitor, OnEndHeadersForStream(11));
+  EXPECT_CALL(visitor, OnEndStream(11));
+
+  const int64_t result = adapter->ProcessBytes(frames);
+  EXPECT_EQ(frames.size(), static_cast<size_t>(result));
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace adapter

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

@@ -10,6 +10,7 @@
 #include "quiche/http2/adapter/http2_protocol.h"
 #include "quiche/http2/adapter/http2_util.h"
 #include "quiche/http2/adapter/http2_visitor_interface.h"
+#include "quiche/http2/adapter/noop_header_validator.h"
 #include "quiche/http2/adapter/oghttp2_util.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 
@@ -216,6 +217,18 @@ bool IsNonAckSettings(const spdy::SpdyFrameIR& frame) {
 
 }  // namespace
 
+OgHttp2Session::PassthroughHeadersHandler::PassthroughHeadersHandler(
+    OgHttp2Session& session, Http2VisitorInterface& visitor)
+    : session_(session), visitor_(visitor) {
+  if (session_.options_.validate_http_headers) {
+    QUICHE_VLOG(2) << "instantiating regular header validator";
+    validator_ = absl::make_unique<HeaderValidator>();
+  } else {
+    QUICHE_VLOG(2) << "instantiating noop header validator";
+    validator_ = absl::make_unique<NoopHeaderValidator>();
+  }
+}
+
 void OgHttp2Session::PassthroughHeadersHandler::OnHeaderBlockStart() {
   result_ = Http2VisitorInterface::HEADER_OK;
   const bool status = visitor_.OnBeginHeadersForStream(stream_id_);
@@ -224,13 +237,14 @@ void OgHttp2Session::PassthroughHeadersHandler::OnHeaderBlockStart() {
         << "Visitor rejected header block, returning HEADER_CONNECTION_ERROR";
     result_ = Http2VisitorInterface::HEADER_CONNECTION_ERROR;
   }
-  validator_.StartHeaderBlock();
+  validator_->StartHeaderBlock();
 }
 
 Http2VisitorInterface::OnHeaderResult InterpretHeaderStatus(
     HeaderValidator::HeaderStatus status) {
   switch (status) {
     case HeaderValidator::HEADER_OK:
+    case HeaderValidator::HEADER_SKIP:
       return Http2VisitorInterface::HEADER_OK;
     case HeaderValidator::HEADER_FIELD_INVALID:
       return Http2VisitorInterface::HEADER_FIELD_INVALID;
@@ -247,7 +261,10 @@ void OgHttp2Session::PassthroughHeadersHandler::OnHeader(
     return;
   }
   const HeaderValidator::HeaderStatus validation_result =
-      validator_.ValidateSingleHeader(key, value);
+      validator_->ValidateSingleHeader(key, value);
+  if (validation_result == HeaderValidator::HEADER_SKIP) {
+    return;
+  }
   if (validation_result != HeaderValidator::HEADER_OK) {
     QUICHE_VLOG(2) << "Header validation failed with result "
                    << static_cast<int>(validation_result);
@@ -261,7 +278,7 @@ void OgHttp2Session::PassthroughHeadersHandler::OnHeaderBlockEnd(
     size_t /* uncompressed_header_bytes */,
     size_t /* compressed_header_bytes */) {
   if (result_ == Http2VisitorInterface::HEADER_OK) {
-    if (!validator_.FinishHeaderBlock(type_)) {
+    if (!validator_->FinishHeaderBlock(type_)) {
       QUICHE_VLOG(1) << "FinishHeaderBlock returned false; returning "
                         "HEADER_HTTP_MESSAGING";
       result_ = Http2VisitorInterface::HEADER_HTTP_MESSAGING;
@@ -322,6 +339,7 @@ struct OgHttp2Session::ProcessBytesResultVisitor {
 
 OgHttp2Session::OgHttp2Session(Http2VisitorInterface& visitor, Options options)
     : visitor_(visitor),
+      options_(options),
       event_forwarder_([this]() { return !latched_error_; }, *this),
       receive_logger_(
           &event_forwarder_, TracePerspectiveAsString(options.perspective),
@@ -337,8 +355,7 @@ OgHttp2Session::OgHttp2Session(Http2VisitorInterface& visitor, Options options)
             SendWindowUpdate(kConnectionStreamId, window_update_delta);
           },
           options.should_window_update_fn,
-          /*update_window_on_notify=*/false),
-      options_(options) {
+          /*update_window_on_notify=*/false) {
   decoder_.set_visitor(&receive_logger_);
   decoder_.set_extension_visitor(this);
   if (options_.max_header_list_bytes) {
@@ -588,10 +605,6 @@ int OgHttp2Session::Send() {
     // case, return early here to avoid sending other frames.
     return InterpretSendResult(continue_writing);
   }
-  while (continue_writing == SendResult::SEND_OK &&
-         !connection_metadata_.empty()) {
-    continue_writing = SendMetadata(0, connection_metadata_);
-  }
   // Notify on new/pending streams closed due to GOAWAY receipt.
   CloseGoAwayRejectedStreams();
   // Wake streams for writes.
@@ -618,18 +631,12 @@ int OgHttp2Session::InterpretSendResult(SendResult result) {
 }
 
 bool OgHttp2Session::HasReadyStream() const {
-  return !metadata_ready_.empty() || !trailers_ready_.empty() ||
+  return !trailers_ready_.empty() ||
          (write_scheduler_.HasReadyStreams() && connection_send_window_ > 0);
 }
 
 Http2StreamId OgHttp2Session::GetNextReadyStream() {
   QUICHE_DCHECK(HasReadyStream());
-  if (!metadata_ready_.empty()) {
-    const Http2StreamId stream_id = *metadata_ready_.begin();
-    // WriteForStream() will re-mark the stream as ready, if necessary.
-    write_scheduler_.MarkStreamNotReady(stream_id);
-    return stream_id;
-  }
   if (!trailers_ready_.empty()) {
     const Http2StreamId stream_id = *trailers_ready_.begin();
     // WriteForStream() will re-mark the stream as ready, if necessary.
@@ -786,14 +793,10 @@ OgHttp2Session::SendResult OgHttp2Session::WriteForStream(
     // HEADERS.
     state.outbound_body = nullptr;
     state.trailers = nullptr;
-    state.outbound_metadata.clear();
     return SendResult::SEND_OK;
   }
-  SendResult connection_can_write = SendResult::SEND_OK;
-  if (!state.outbound_metadata.empty()) {
-    connection_can_write = SendMetadata(stream_id, state.outbound_metadata);
-  }
 
+  SendResult connection_can_write = SendResult::SEND_OK;
   if (state.outbound_body == nullptr ||
       (!options_.trailers_require_end_data && state.data_deferred)) {
     // No data to send, but there might be trailers.
@@ -900,19 +903,18 @@ OgHttp2Session::SendResult OgHttp2Session::WriteForStream(
                                       : SendResult::SEND_OK;
 }
 
-OgHttp2Session::SendResult OgHttp2Session::SendMetadata(
-    Http2StreamId stream_id, OgHttp2Session::MetadataSequence& sequence) {
+void OgHttp2Session::SerializeMetadata(Http2StreamId stream_id,
+                                       std::unique_ptr<MetadataSource> source) {
   const uint32_t max_payload_size =
       std::min(kMaxAllowedMetadataFrameSize, max_frame_payload_);
   auto payload_buffer = absl::make_unique<uint8_t[]>(max_payload_size);
-  while (!sequence.empty()) {
-    MetadataSource& source = *sequence.front();
 
+  while (true) {
     auto [written, end_metadata] =
-        source.Pack(payload_buffer.get(), max_payload_size);
+        source->Pack(payload_buffer.get(), max_payload_size);
     if (written < 0) {
-      // Did not touch the connection, so perhaps writes are still possible.
-      return SendResult::SEND_OK;
+      // Unable to pack any metadata.
+      return;
     }
     QUICHE_DCHECK_LE(static_cast<size_t>(written), max_payload_size);
     auto payload = absl::string_view(
@@ -921,11 +923,9 @@ OgHttp2Session::SendResult OgHttp2Session::SendMetadata(
         stream_id, kMetadataFrameType, end_metadata ? kMetadataEndFlag : 0u,
         std::string(payload)));
     if (end_metadata) {
-      sequence.erase(sequence.begin());
-      metadata_ready_.erase(stream_id);
+      return;
     }
   }
-  return SendQueuedFrames();
 }
 
 int32_t OgHttp2Session::SubmitRequest(
@@ -1003,13 +1003,7 @@ int OgHttp2Session::SubmitTrailer(Http2StreamId stream_id,
 
 void OgHttp2Session::SubmitMetadata(Http2StreamId stream_id,
                                     std::unique_ptr<MetadataSource> source) {
-  if (stream_id == 0) {
-    connection_metadata_.push_back(std::move(source));
-  } else {
-    auto iter = CreateStream(stream_id);
-    iter->second.outbound_metadata.push_back(std::move(source));
-    metadata_ready_.insert(stream_id);
-  }
+  SerializeMetadata(stream_id, std::move(source));
 }
 
 void OgHttp2Session::SubmitSettings(absl::Span<const Http2Setting> settings) {
@@ -1344,7 +1338,8 @@ bool OgHttp2Session::OnGoAwayFrameData(const char* /*goaway_data*/, size_t
 }
 
 void OgHttp2Session::OnHeaders(spdy::SpdyStreamId stream_id,
-                               bool /*has_priority*/, int /*weight*/,
+                               size_t /*payload_length*/, bool /*has_priority*/,
+                               int /*weight*/,
                                spdy::SpdyStreamId /*parent_stream_id*/,
                                bool /*exclusive*/, bool fin, bool /*end*/) {
   if (stream_id % 2 == 0) {
@@ -1440,8 +1435,8 @@ void OgHttp2Session::OnPushPromise(spdy::SpdyStreamId /*stream_id*/,
                       ConnectionError::kInvalidPushPromise);
 }
 
-void OgHttp2Session::OnContinuation(spdy::SpdyStreamId /*stream_id*/, bool
-                                    /*end*/) {}
+void OgHttp2Session::OnContinuation(spdy::SpdyStreamId /*stream_id*/,
+                                    size_t /*payload_length*/, bool /*end*/) {}
 
 void OgHttp2Session::OnAltSvc(spdy::SpdyStreamId /*stream_id*/,
                               absl::string_view /*origin*/,
@@ -1604,7 +1599,7 @@ void OgHttp2Session::HandleOutboundSettings(
         if (value == 1u && IsServerSession()) {
           // Allow extended CONNECT semantics even before SETTINGS are acked, to
           // make things easier for clients.
-          headers_handler_.AllowConnect();
+          headers_handler_.SetAllowExtendedConnect();
         }
         break;
       case HEADER_TABLE_SIZE:
@@ -1754,7 +1749,6 @@ void OgHttp2Session::CloseStream(Http2StreamId stream_id,
   }
   stream_map_.erase(stream_id);
   trailers_ready_.erase(stream_id);
-  metadata_ready_.erase(stream_id);
   streams_reset_.erase(stream_id);
   queued_frames_.erase(stream_id);
   if (write_scheduler_.StreamRegistered(stream_id)) {

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

@@ -13,6 +13,7 @@
 #include "quiche/http2/adapter/data_source.h"
 #include "quiche/http2/adapter/event_forwarder.h"
 #include "quiche/http2/adapter/header_validator.h"
+#include "quiche/http2/adapter/header_validator_base.h"
 #include "quiche/http2/adapter/http2_protocol.h"
 #include "quiche/http2/adapter/http2_session.h"
 #include "quiche/http2/adapter/http2_util.h"
@@ -71,6 +72,9 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
     // Whether to allow `obs-text` (characters from hexadecimal 0x80 to 0xff) in
     // header field values.
     bool allow_obs_text = true;
+    // If true, validates header field names and values according to RFC 7230
+    // and RFC 7540.
+    bool validate_http_headers = true;
   };
 
   OgHttp2Session(Http2VisitorInterface& visitor, Options options);
@@ -145,8 +149,7 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
   }
   bool want_write() const override {
     return !fatal_send_error_ &&
-           (!frames_.empty() || !buffered_data_.empty() ||
-            !connection_metadata_.empty() || HasReadyStream() ||
+           (!frames_.empty() || !buffered_data_.empty() || HasReadyStream() ||
             !goaway_rejected_streams_.empty());
   }
   int GetRemoteWindowSize() const override { return connection_send_window_; }
@@ -177,14 +180,16 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
   void OnGoAway(spdy::SpdyStreamId last_accepted_stream_id,
                 spdy::SpdyErrorCode error_code) override;
   bool OnGoAwayFrameData(const char* goaway_data, size_t len) override;
-  void OnHeaders(spdy::SpdyStreamId stream_id, bool has_priority, int weight,
+  void OnHeaders(spdy::SpdyStreamId stream_id, size_t payload_length,
+                 bool has_priority, int weight,
                  spdy::SpdyStreamId parent_stream_id, bool exclusive, bool fin,
                  bool end) override;
   void OnWindowUpdate(spdy::SpdyStreamId stream_id,
                       int delta_window_size) override;
   void OnPushPromise(spdy::SpdyStreamId stream_id,
                      spdy::SpdyStreamId promised_stream_id, bool end) override;
-  void OnContinuation(spdy::SpdyStreamId stream_id, bool end) override;
+  void OnContinuation(spdy::SpdyStreamId stream_id, size_t payload_length,
+                      bool end) override;
   void OnAltSvc(spdy::SpdyStreamId /*stream_id*/, absl::string_view /*origin*/,
                 const spdy::SpdyAltSvcWireFormat::
                     AlternativeServiceVector& /*altsvc_vector*/) override;
@@ -209,8 +214,6 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
   void OnFramePayload(const char* data, size_t len) override;
 
  private:
-  using MetadataSequence = std::vector<std::unique_ptr<MetadataSource>>;
-
   struct QUICHE_EXPORT_PRIVATE StreamState {
     StreamState(int32_t stream_receive_window, int32_t stream_send_window,
                 WindowManager::WindowUpdateListener listener,
@@ -222,7 +225,6 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
 
     WindowManager window_manager;
     std::unique_ptr<DataFrameSource> outbound_body;
-    MetadataSequence outbound_metadata;
     std::unique_ptr<spdy::SpdyHeaderBlock> trailers;
     void* user_data = nullptr;
     int32_t send_window;
@@ -245,9 +247,8 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
   class QUICHE_EXPORT_PRIVATE PassthroughHeadersHandler
       : public spdy::SpdyHeadersHandlerInterface {
    public:
-    explicit PassthroughHeadersHandler(OgHttp2Session& session,
-                                       Http2VisitorInterface& visitor)
-        : session_(session), visitor_(visitor) {}
+    PassthroughHeadersHandler(OgHttp2Session& session,
+                              Http2VisitorInterface& visitor);
 
     void set_stream_id(Http2StreamId stream_id) {
       stream_id_ = stream_id;
@@ -265,18 +266,18 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
     absl::string_view status_header() const {
       QUICHE_DCHECK(type_ == HeaderType::RESPONSE ||
                     type_ == HeaderType::RESPONSE_100);
-      return validator_.status_header();
+      return validator_->status_header();
     }
     absl::optional<size_t> content_length() const {
-      return validator_.content_length();
+      return validator_->content_length();
     }
-    void AllowConnect() { validator_.AllowConnect(); }
+    void SetAllowExtendedConnect() { validator_->SetAllowExtendedConnect(); }
     void SetMaxFieldSize(uint32_t field_size) {
-      validator_.SetMaxFieldSize(field_size);
+      validator_->SetMaxFieldSize(field_size);
     }
     void SetAllowObsText(bool allow) {
-      validator_.SetObsTextOption(allow ? ObsTextOption::kAllow
-                                        : ObsTextOption::kDisallow);
+      validator_->SetObsTextOption(allow ? ObsTextOption::kAllow
+                                         : ObsTextOption::kDisallow);
     }
     bool CanReceiveBody() const;
 
@@ -287,7 +288,7 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
     Http2VisitorInterface::OnHeaderResult result_ =
         Http2VisitorInterface::HEADER_OK;
     // Validates header blocks according to the HTTP/2 specification.
-    HeaderValidator validator_;
+    std::unique_ptr<HeaderValidatorBase> validator_;
     HeaderType type_ = HeaderType::RESPONSE;
     bool frame_contains_fin_ = false;
   };
@@ -359,7 +360,8 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
   // Writes DATA frames for stream `stream_id`.
   SendResult WriteForStream(Http2StreamId stream_id);
 
-  SendResult SendMetadata(Http2StreamId stream_id, MetadataSequence& sequence);
+  void SerializeMetadata(Http2StreamId stream_id,
+                         std::unique_ptr<MetadataSource> source);
 
   void SendHeaders(Http2StreamId stream_id, spdy::SpdyHeaderBlock headers,
                    bool end_stream);
@@ -429,6 +431,8 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
   // Receives events when inbound frames are parsed.
   Http2VisitorInterface& visitor_;
 
+  const Options options_;
+
   // Forwards received events to the session if it can accept them.
   EventForwarder event_forwarder_;
 
@@ -487,13 +491,9 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
   absl::flat_hash_map<Http2StreamId, int> queued_frames_;
   // Includes streams that are currently ready to write trailers.
   absl::flat_hash_set<Http2StreamId> trailers_ready_;
-  // Includes streams that are currently ready to write metadata.
-  absl::flat_hash_set<Http2StreamId> metadata_ready_;
   // Includes streams that will not be written due to receipt of GOAWAY.
   absl::flat_hash_set<Http2StreamId> goaway_rejected_streams_;
 
-  MetadataSequence connection_metadata_;
-
   Http2StreamId next_stream_id_ = 1;
   // The highest received stream ID is the highest stream ID in any frame read
   // from the peer. The highest processed stream ID is the highest stream ID for
@@ -519,7 +519,6 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
       std::numeric_limits<uint32_t>::max();
   uint32_t max_inbound_concurrent_streams_ =
       std::numeric_limits<uint32_t>::max();
-  const Options options_;
 
   // The HPACK encoder header table capacity that will be applied when
   // acking SETTINGS from the peer. Only contains a value if the peer advertises

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

@@ -61,7 +61,7 @@ bool TestDataFrameSource::Send(absl::string_view frame_header,
   } else if (result == 0) {
     // Write blocked.
     return false;
-  } else if (static_cast<const size_t>(result) < concatenated.size()) {
+  } else if (static_cast<size_t>(result) < concatenated.size()) {
     // Probably need to handle this better within this test class.
     QUICHE_LOG(DFATAL)
         << "DATA frame not fully flushed. Connection will be corrupt!";

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

@@ -4,8 +4,8 @@
 
 #include "absl/functional/bind_front.h"
 #include "quiche/http2/test_tools/http2_random.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 {
@@ -24,7 +24,7 @@ class WindowManagerPeer {
 
 namespace {
 
-class WindowManagerTest : public ::testing::Test {
+class WindowManagerTest : public quiche::test::QuicheTest {
  protected:
   WindowManagerTest()
       : wm_(kDefaultLimit, absl::bind_front(&WindowManagerTest::OnCall, this)),
@@ -72,7 +72,9 @@ TEST_F(WindowManagerTest, DataBufferedAndFlushed) {
     wm_.MarkDataBuffered(buffered);
     total_buffered += buffered;
     EXPECT_TRUE(call_sequence_.empty());
-    int64_t flushed = random_.Uniform(total_buffered - total_flushed);
+    int64_t flushed = (total_buffered - total_flushed) > 0
+                          ? random_.Uniform(total_buffered - total_flushed)
+                          : 0;
     wm_.MarkDataFlushed(flushed);
     total_flushed += flushed;
   }
@@ -99,8 +101,12 @@ TEST_F(WindowManagerTest, AvoidBufferedUnderflow) {
   wm_.MarkDataBuffered(42);
   EXPECT_EQ(peer_.buffered(), 42u);
   // Don't flush more than has been buffered!
-  EXPECT_QUICHE_BUG(wm_.MarkDataFlushed(43), "buffered underflow");
-  EXPECT_EQ(peer_.buffered(), 0u);
+  EXPECT_QUICHE_BUG(
+      {
+        wm_.MarkDataFlushed(43);
+        EXPECT_EQ(peer_.buffered(), 0u);
+      },
+      "buffered underflow");
 }
 
 // This test verifies that WindowManager notifies its listener when window is