@fails-components/webtransport 0.0.1 → 0.0.2

package/third_party/quiche/quiche/quic/core/http/http_encoder_test.cc

@@ -17,10 +17,8 @@ namespace test {
 TEST(HttpEncoderTest, SerializeDataFrameHeader) {
   quiche::QuicheBuffer buffer = HttpEncoder::SerializeDataFrameHeader(
       /* payload_length = */ 5, quiche::SimpleBufferAllocator::Get());
-  char output[] = {// type (DATA)
-                   0x00,
-                   // length
-                   0x05};
+  char output[] = {0x00,   // type (DATA)
+                   0x05};  // length
   EXPECT_EQ(ABSL_ARRAYSIZE(output), buffer.size());
   quiche::test::CompareCharArraysWithHexError(
       "DATA", buffer.data(), buffer.size(), output, ABSL_ARRAYSIZE(output));
@@ -30,10 +28,8 @@ TEST(HttpEncoderTest, SerializeHeadersFrameHeader) {
   std::unique_ptr<char[]> buffer;
   uint64_t length = HttpEncoder::SerializeHeadersFrameHeader(
       /* payload_length = */ 7, &buffer);
-  char output[] = {// type (HEADERS)
-                   0x01,
-                   // length
-                   0x07};
+  char output[] = {0x01,   // type (HEADERS)
+                   0x07};  // length
   EXPECT_EQ(ABSL_ARRAYSIZE(output), length);
   quiche::test::CompareCharArraysWithHexError("HEADERS", buffer.get(), length,
                                               output, ABSL_ARRAYSIZE(output));
@@ -44,22 +40,14 @@ TEST(HttpEncoderTest, SerializeSettingsFrame) {
   settings.values[1] = 2;
   settings.values[6] = 5;
   settings.values[256] = 4;
-  char output[] = {// type (SETTINGS)
-                   0x04,
-                   // length
-                   0x07,
-                   // identifier (SETTINGS_QPACK_MAX_TABLE_CAPACITY)
-                   0x01,
-                   // content
-                   0x02,
-                   // identifier (SETTINGS_MAX_HEADER_LIST_SIZE)
-                   0x06,
-                   // content
-                   0x05,
-                   // identifier (256 in variable length integer)
-                   0x40 + 0x01, 0x00,
-                   // content
-                   0x04};
+  char output[] = {0x04,  // type (SETTINGS)
+                   0x07,  // length
+                   0x01,  // identifier (SETTINGS_QPACK_MAX_TABLE_CAPACITY)
+                   0x02,  // content
+                   0x06,  // identifier (SETTINGS_MAX_HEADER_LIST_SIZE)
+                   0x05,  // content
+                   0x41, 0x00,  // identifier 0x100, varint encoded
+                   0x04};       // content
   std::unique_ptr<char[]> buffer;
   uint64_t length = HttpEncoder::SerializeSettingsFrame(settings, &buffer);
   EXPECT_EQ(ABSL_ARRAYSIZE(output), length);
@@ -70,12 +58,9 @@ TEST(HttpEncoderTest, SerializeSettingsFrame) {
 TEST(HttpEncoderTest, SerializeGoAwayFrame) {
   GoAwayFrame goaway;
   goaway.id = 0x1;
-  char output[] = {// type (GOAWAY)
-                   0x07,
-                   // length
-                   0x1,
-                   // ID
-                   0x01};
+  char output[] = {0x07,   // type (GOAWAY)
+                   0x1,    // length
+                   0x01};  // ID
   std::unique_ptr<char[]> buffer;
   uint64_t length = HttpEncoder::SerializeGoAwayFrame(goaway, &buffer);
   EXPECT_EQ(ABSL_ARRAYSIZE(output), length);
@@ -138,5 +123,16 @@ TEST(HttpEncoderTest, SerializeWebTransportStreamFrameHeader) {
       "WEBTRANSPORT_STREAM", buffer.get(), length, output, sizeof(output));
 }
 
+TEST(HttpEncoderTest, SerializeMetadataFrameHeader) {
+  std::unique_ptr<char[]> buffer;
+  uint64_t length = HttpEncoder::SerializeMetadataFrameHeader(
+      /* payload_length = */ 7, &buffer);
+  char output[] = {0x40, 0x4d,  // type (METADATA, 0x4d, varint encoded)
+                   0x07};       // length
+  EXPECT_EQ(ABSL_ARRAYSIZE(output), length);
+  quiche::test::CompareCharArraysWithHexError("METADATA", buffer.get(), length,
+                                              output, ABSL_ARRAYSIZE(output));
+}
+
 }  // namespace test
 }  // namespace quic

package/third_party/quiche/quiche/quic/core/http/http_frames.h

@@ -34,6 +34,7 @@ enum class HttpFrameType {
   PRIORITY_UPDATE_REQUEST_STREAM = 0xF0700,
   // https://www.ietf.org/archive/id/draft-ietf-webtrans-http3-00.html
   WEBTRANSPORT_STREAM = 0x41,
+  METADATA = 0x4d,
 };
 
 // 7.2.1.  DATA

package/third_party/quiche/quiche/quic/core/http/quic_server_session_base.cc

@@ -88,7 +88,7 @@ void QuicServerSessionBase::OnConfigNegotiated() {
 
   enable_sending_bandwidth_estimate_when_network_idle_ =
       GetQuicRestartFlag(
-          quic_enable_sending_bandwidth_estimate_when_network_idle) &&
+          quic_enable_sending_bandwidth_estimate_when_network_idle_v2) &&
       version().HasIetfQuicFrames() &&
       ContainsQuicTag(config()->ReceivedConnectionOptions(), kBWID);
 
@@ -146,7 +146,7 @@ void QuicServerSessionBase::OnBandwidthUpdateTimeout() {
     const bool success = MaybeSendAddressToken();
     QUIC_BUG_IF(QUIC_BUG_25522, !success) << "Failed to send address token.";
     QUIC_RESTART_FLAG_COUNT_N(
-        quic_enable_sending_bandwidth_estimate_when_network_idle, 2, 3);
+        quic_enable_sending_bandwidth_estimate_when_network_idle_v2, 2, 3);
   }
 }
 
@@ -154,9 +154,9 @@ void QuicServerSessionBase::OnCongestionWindowChange(QuicTime now) {
   // Sending bandwidth is no longer conditioned on if session does bandwidth
   // resumption.
   if (GetQuicRestartFlag(
-          quic_enable_sending_bandwidth_estimate_when_network_idle)) {
+          quic_enable_sending_bandwidth_estimate_when_network_idle_v2)) {
     QUIC_RESTART_FLAG_COUNT_N(
-        quic_enable_sending_bandwidth_estimate_when_network_idle, 3, 3);
+        quic_enable_sending_bandwidth_estimate_when_network_idle_v2, 3, 3);
     return;
   }
   if (!bandwidth_resumption_enabled_) {

package/third_party/quiche/quiche/quic/core/http/quic_server_session_base_test.cc

@@ -608,7 +608,7 @@ TEST_P(QuicServerSessionBaseTest, BandwidthEstimates) {
                                     HAS_RETRANSMITTABLE_DATA, true);
 
   if (GetQuicRestartFlag(
-          quic_enable_sending_bandwidth_estimate_when_network_idle)) {
+          quic_enable_sending_bandwidth_estimate_when_network_idle_v2)) {
     EXPECT_CALL(*connection_, OnSendConnectionState(_)).Times(0);
   } else {
     // Verify that the proto has exactly the values we expect.

package/third_party/quiche/quiche/quic/core/http/quic_spdy_client_session.cc

@@ -38,7 +38,11 @@ void QuicSpdyClientSession::Initialize() {
   crypto_stream_ = CreateQuicCryptoStream();
   if (config()->HasClientRequestedIndependentOption(kQLVE,
                                                     Perspective::IS_CLIENT)) {
-    connection()->EnableLegacyVersionEncapsulation(server_id_.host());
+    if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
+      QUIC_CODE_COUNT(quic_disable_legacy_version_encapsulation_client_init);
+    } else {
+      connection()->EnableLegacyVersionEncapsulation(server_id_.host());
+    }
   }
   QuicSpdyClientSessionBase::Initialize();
 }

package/third_party/quiche/quiche/quic/core/http/quic_spdy_stream.cc

@@ -185,8 +185,6 @@ QuicSpdyStream::QuicSpdyStream(QuicStreamId id, QuicSpdySession* spdy_session,
       headers_payload_length_(0),
       trailers_decompressed_(false),
       trailers_consumed_(false),
-      qpack_decoded_headers_accumulator_reset_reason_(
-          QpackDecodedHeadersAccumulatorResetReason::kUnSet),
       http_decoder_visitor_(std::make_unique<HttpDecoderVisitor>(this)),
       decoder_(http_decoder_visitor_.get(),
                HttpDecoderOptionsForBidiStream(spdy_session)),
@@ -223,8 +221,6 @@ QuicSpdyStream::QuicSpdyStream(PendingStream* pending,
       headers_payload_length_(0),
       trailers_decompressed_(false),
       trailers_consumed_(false),
-      qpack_decoded_headers_accumulator_reset_reason_(
-          QpackDecodedHeadersAccumulatorResetReason::kUnSet),
       http_decoder_visitor_(std::make_unique<HttpDecoderVisitor>(this)),
       decoder_(http_decoder_visitor_.get()),
       sequencer_offset_(sequencer()->NumBytesConsumed()),
@@ -561,8 +557,6 @@ void QuicSpdyStream::OnHeadersDecoded(QuicHeaderList headers,
                                       bool header_list_size_limit_exceeded) {
   header_list_size_limit_exceeded_ = header_list_size_limit_exceeded;
   qpack_decoded_headers_accumulator_.reset();
-  qpack_decoded_headers_accumulator_reset_reason_ =
-      QpackDecodedHeadersAccumulatorResetReason::kResetInOnHeadersDecoded;
 
   QuicSpdySession::LogHeaderCompressionRatioHistogram(
       /* using_qpack = */ true,
@@ -592,8 +586,6 @@ void QuicSpdyStream::OnHeadersDecoded(QuicHeaderList headers,
 void QuicSpdyStream::OnHeaderDecodingError(QuicErrorCode error_code,
                                            absl::string_view error_message) {
   qpack_decoded_headers_accumulator_.reset();
-  qpack_decoded_headers_accumulator_reset_reason_ =
-      QpackDecodedHeadersAccumulatorResetReason::kResetInOnHeaderDecodingError;
 
   std::string connection_close_error_message = absl::StrCat(
       "Error decoding ", headers_decompressed_ ? "trailers" : "headers",
@@ -734,20 +726,13 @@ void QuicSpdyStream::OnStreamReset(const QuicRstStreamFrame& frame) {
     return;
   }
 
-  // TODO(bnc): Merge the two blocks below when both
-  // quic_abort_qpack_on_stream_reset and quic_fix_on_stream_reset are
-  // deprecated.
+  // TODO(bnc): Merge the two blocks below when deprecating
+  // quic_fix_on_stream_reset.
   if (frame.error_code != QUIC_STREAM_NO_ERROR) {
     if (VersionUsesHttp3(transport_version()) && !fin_received() &&
         spdy_session_->qpack_decoder()) {
-      QUIC_CODE_COUNT_N(quic_abort_qpack_on_stream_reset, 1, 2);
       spdy_session_->qpack_decoder()->OnStreamReset(id());
-      if (GetQuicReloadableFlag(quic_abort_qpack_on_stream_reset)) {
-        QUIC_RELOADABLE_FLAG_COUNT_N(quic_abort_qpack_on_stream_reset, 1, 2);
-        qpack_decoded_headers_accumulator_.reset();
-        qpack_decoded_headers_accumulator_reset_reason_ =
-            QpackDecodedHeadersAccumulatorResetReason::kResetInOnStreamReset1;
-      }
+      qpack_decoded_headers_accumulator_.reset();
     }
 
     QuicStream::OnStreamReset(frame);
@@ -761,8 +746,6 @@ void QuicSpdyStream::OnStreamReset(const QuicRstStreamFrame& frame) {
       if (!fin_received() && spdy_session_->qpack_decoder()) {
         spdy_session_->qpack_decoder()->OnStreamReset(id());
         qpack_decoded_headers_accumulator_.reset();
-        qpack_decoded_headers_accumulator_reset_reason_ =
-            QpackDecodedHeadersAccumulatorResetReason::kResetInOnStreamReset2;
       }
 
       QuicStream::OnStreamReset(frame);
@@ -781,14 +764,8 @@ void QuicSpdyStream::OnStreamReset(const QuicRstStreamFrame& frame) {
 void QuicSpdyStream::ResetWithError(QuicResetStreamError error) {
   if (VersionUsesHttp3(transport_version()) && !fin_received() &&
       spdy_session_->qpack_decoder() && web_transport_data_ == nullptr) {
-    QUIC_CODE_COUNT_N(quic_abort_qpack_on_stream_reset, 2, 2);
     spdy_session_->qpack_decoder()->OnStreamReset(id());
-    if (GetQuicReloadableFlag(quic_abort_qpack_on_stream_reset)) {
-      QUIC_RELOADABLE_FLAG_COUNT_N(quic_abort_qpack_on_stream_reset, 2, 2);
-      qpack_decoded_headers_accumulator_.reset();
-      qpack_decoded_headers_accumulator_reset_reason_ =
-          QpackDecodedHeadersAccumulatorResetReason::kResetInResetWithError;
-    }
+    qpack_decoded_headers_accumulator_.reset();
   }
 
   QuicStream::ResetWithError(error);
@@ -890,8 +867,6 @@ void QuicSpdyStream::OnClose() {
   QuicStream::OnClose();
 
   qpack_decoded_headers_accumulator_.reset();
-  qpack_decoded_headers_accumulator_reset_reason_ =
-      QpackDecodedHeadersAccumulatorResetReason::kResetInOnClose;
 
   if (visitor_) {
     Visitor* visitor = visitor_;
@@ -1085,8 +1060,7 @@ bool QuicSpdyStream::OnHeadersFramePayload(absl::string_view payload) {
   QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   if (!qpack_decoded_headers_accumulator_) {
-    QUIC_BUG(b215142466_OnHeadersFramePayload)
-        << static_cast<int>(qpack_decoded_headers_accumulator_reset_reason_);
+    QUIC_BUG(b215142466_OnHeadersFramePayload);
     OnHeaderDecodingError(QUIC_INTERNAL_ERROR,
                           "qpack_decoded_headers_accumulator_ is nullptr");
     return false;
@@ -1107,8 +1081,7 @@ bool QuicSpdyStream::OnHeadersFrameEnd() {
   QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   if (!qpack_decoded_headers_accumulator_) {
-    QUIC_BUG(b215142466_OnHeadersFrameEnd)
-        << static_cast<int>(qpack_decoded_headers_accumulator_reset_reason_);
+    QUIC_BUG(b215142466_OnHeadersFrameEnd);
     OnHeaderDecodingError(QUIC_INTERNAL_ERROR,
                           "qpack_decoded_headers_accumulator_ is nullptr");
     return false;

package/third_party/quiche/quiche/quic/core/http/quic_spdy_stream.h

@@ -336,20 +336,6 @@ class QUIC_EXPORT_PRIVATE QuicSpdyStream
     WebTransportStreamAdapter adapter;
   };
 
-  // Reason codes for `qpack_decoded_headers_accumulator_` being nullptr.
-  enum class QpackDecodedHeadersAccumulatorResetReason {
-    // `qpack_decoded_headers_accumulator_` was default constructed to nullptr.
-    kUnSet = 0,
-    // `qpack_decoded_headers_accumulator_` was reset in the corresponding
-    // method.
-    kResetInOnHeadersDecoded = 1,
-    kResetInOnHeaderDecodingError = 2,
-    kResetInOnStreamReset1 = 3,
-    kResetInOnStreamReset2 = 4,
-    kResetInResetWithError = 5,
-    kResetInOnClose = 6,
-  };
-
   // Called by HttpDecoderVisitor.
   bool OnDataFrameStart(QuicByteCount header_length,
                         QuicByteCount payload_length);
@@ -417,9 +403,6 @@ class QUIC_EXPORT_PRIVATE QuicSpdyStream
   // Headers accumulator for decoding HEADERS frame payload.
   std::unique_ptr<QpackDecodedHeadersAccumulator>
       qpack_decoded_headers_accumulator_;
-  // Reason for `qpack_decoded_headers_accumulator_` being nullptr.
-  QpackDecodedHeadersAccumulatorResetReason
-      qpack_decoded_headers_accumulator_reset_reason_;
   // Visitor of the HttpDecoder.
   std::unique_ptr<HttpDecoderVisitor> http_decoder_visitor_;
   // HttpDecoder for processing raw incoming stream frames.

package/third_party/quiche/quiche/quic/core/http/quic_spdy_stream_test.cc

@@ -2564,27 +2564,13 @@ TEST_P(QuicSpdyStreamTest, HeaderDecodingUnblockedAfterResetReceived) {
                          /* offset = */ 1, _, _, _));
 
   // OnStreamReset() is called when RESET_STREAM frame is received from peer.
+  // This aborts header decompression.
   stream_->OnStreamReset(QuicRstStreamFrame(
       kInvalidControlFrameId, stream_->id(), QUIC_STREAM_CANCELLED, 0));
 
-  if (!GetQuicReloadableFlag(quic_abort_qpack_on_stream_reset)) {
-    // Header acknowledgement.
-    EXPECT_CALL(*session_,
-                WritevData(decoder_send_stream->id(), /* write_length = */ 1,
-                           /* offset = */ 2, _, _, _));
-    EXPECT_CALL(debug_visitor, OnHeadersDecoded(stream_->id(), _));
-  }
-
   // Deliver dynamic table entry to decoder.
   session_->qpack_decoder()->OnInsertWithoutNameReference("foo", "bar");
-
-  if (GetQuicReloadableFlag(quic_abort_qpack_on_stream_reset)) {
-    EXPECT_FALSE(stream_->headers_decompressed());
-  } else {
-    // Verify headers.
-    EXPECT_TRUE(stream_->headers_decompressed());
-    EXPECT_THAT(stream_->header_list(), ElementsAre(Pair("foo", "bar")));
-  }
+  EXPECT_FALSE(stream_->headers_decompressed());
 }
 
 class QuicSpdyStreamIncrementalConsumptionTest : public QuicSpdyStreamTest {
@@ -3209,15 +3195,14 @@ TEST_P(QuicSpdyStreamTest,
   // Resets `qpack_decoded_headers_accumulator_`.
   stream_->OnHeadersDecoded({}, false);
 
-  // This private method should never be called when
-  // `qpack_decoded_headers_accumulator_` is nullptr.  The number 1 identifies
-  // the site where `qpack_decoded_headers_accumulator_` was last reset.
   EXPECT_QUIC_BUG(
       {
         EXPECT_CALL(*connection_, CloseConnection(_, _, _));
+        // This private method should never be called when
+        // `qpack_decoded_headers_accumulator_` is nullptr.
         EXPECT_FALSE(QuicSpdyStreamPeer::OnHeadersFrameEnd(stream_));
       },
-      "b215142466_OnHeadersFrameEnd.?: 1");
+      "b215142466_OnHeadersFrameEnd");
 }
 
 }  // namespace

package/third_party/quiche/quiche/quic/core/io/quic_event_loop.h

@@ -0,0 +1,81 @@
+// Copyright 2022 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_QUIC_IO_QUIC_EVENT_LOOP_H_
+#define QUICHE_QUIC_IO_QUIC_EVENT_LOOP_H_
+
+#include <cstdint>
+#include <memory>
+
+#include "absl/base/attributes.h"
+#include "quiche/quic/core/quic_alarm_factory.h"
+#include "quiche/quic/core/quic_udp_socket.h"
+
+namespace quic {
+
+// A bitmask indicating a set of I/O events.
+using QuicSocketEventMask = uint8_t;
+inline constexpr QuicSocketEventMask kSocketEventReadable = 0x01;
+inline constexpr QuicSocketEventMask kSocketEventWritable = 0x02;
+inline constexpr QuicSocketEventMask kSocketEventError = 0x04;
+
+class QuicEventLoop;
+
+// A listener associated with a file descriptor.
+class QUICHE_NO_EXPORT QuicSocketEventListener {
+ public:
+  virtual ~QuicSocketEventListener() = default;
+
+  virtual void OnSocketEvent(QuicEventLoop* event_loop, QuicUdpSocketFd fd,
+                             QuicSocketEventMask events) = 0;
+};
+
+// An abstraction for an event loop that can handle alarms and notify the
+// listener about I/O events occuring to the registered UDP sockets.
+//
+// Note on error handling: while most of the methods below return a boolean to
+// indicate whether the operation has succeeded or not, some will QUIC_BUG
+// instead.
+class QUICHE_NO_EXPORT QuicEventLoop {
+ public:
+  virtual ~QuicEventLoop() = default;
+
+  // Indicates whether the event loop implementation supports edge-triggered
+  // notifications.  If true, all of the events are permanent and are notified
+  // as long as they are registered.  If false, whenever an event is triggered,
+  // the event registration is unset and has to be re-armed using RearmSocket().
+  virtual bool SupportsEdgeTriggered() const = 0;
+
+  // Watches for all of the requested |events| that occur on the |fd| and
+  // notifies the |listener| about them.  |fd| must not be already registered;
+  // if it is, the function returns false.  The |listener| must be alive for as
+  // long as it is registered.
+  virtual ABSL_MUST_USE_RESULT bool RegisterSocket(
+      QuicUdpSocketFd fd, QuicSocketEventMask events,
+      QuicSocketEventListener* listener) = 0;
+  // Removes the listener associated with |fd|.  Returns false if the listener
+  // is not found.
+  virtual ABSL_MUST_USE_RESULT bool UnregisterSocket(QuicUdpSocketFd fd) = 0;
+  // Adds |events| to the list of the listened events for |fd|, given that |fd|
+  // is already registered.  Must be only called if SupportsEdgeTriggered() is
+  // false.
+  virtual ABSL_MUST_USE_RESULT bool RearmSocket(QuicUdpSocketFd fd,
+                                                QuicSocketEventMask events) = 0;
+  // Causes the |fd| to be notified of |events| on the next event loop iteration
+  // even if none of the specified events has happened.
+  virtual ABSL_MUST_USE_RESULT bool ArtificiallyNotifyEvent(
+      QuicUdpSocketFd fd, QuicSocketEventMask events) = 0;
+
+  // Runs a single iteration of the event loop.  The iteration will run for at
+  // most |default_timeout|.
+  virtual void RunEventLoopOnce(QuicTime::Delta default_timeout) = 0;
+
+  // Returns an alarm factory that allows alarms to be scheduled on this event
+  // loop.  The factory is owned by the event loop.
+  virtual QuicAlarmFactory* GetAlarmFactory() = 0;
+};
+
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_IO_QUIC_EVENT_LOOP_H_