@fails-components/webtransport 0.0.1 → 0.0.2

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

@@ -5883,12 +5883,12 @@ TEST(NgHttp2AdapterTest, AutomaticPingAcksDisabled) {
   EXPECT_THAT(visitor.data(), EqualsFrames({SpdyFrameType::SETTINGS}));
 }
 
-TEST(NgHttp2AdapterTest, InvalidMaxFrameSize) {
+TEST(NgHttp2AdapterTest, InvalidMaxFrameSizeSetting) {
   DataSavingVisitor visitor;
   auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);
 
   const std::string frames =
-      TestFrameSequence().ClientPreface({{MAX_FRAME_SIZE, 3}}).Serialize();
+      TestFrameSequence().ClientPreface({{MAX_FRAME_SIZE, 3u}}).Serialize();
   testing::InSequence s;
 
   // Client preface
@@ -5912,6 +5912,90 @@ TEST(NgHttp2AdapterTest, InvalidMaxFrameSize) {
   EXPECT_THAT(visitor.data(), EqualsFrames({SpdyFrameType::GOAWAY}));
 }
 
+TEST(OgHttp2AdapterTest, InvalidPushSetting) {
+  DataSavingVisitor visitor;
+  auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);
+
+  const std::string frames =
+      TestFrameSequence().ClientPreface({{ENABLE_PUSH, 3u}}).Serialize();
+  testing::InSequence s;
+
+  // Client preface
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnInvalidFrame(0, _));
+
+  const int64_t read_result = adapter->ProcessBytes(frames);
+  EXPECT_EQ(static_cast<size_t>(read_result), frames.size());
+
+  EXPECT_TRUE(adapter->want_write());
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(GOAWAY, 0, _, 0x0));
+  EXPECT_CALL(visitor,
+              OnFrameSent(GOAWAY, 0, _, 0x0,
+                          static_cast<int>(Http2ErrorCode::PROTOCOL_ERROR)));
+
+  int send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
+  EXPECT_THAT(visitor.data(), EqualsFrames({SpdyFrameType::GOAWAY}));
+}
+
+TEST(NgHttp2AdapterTest, InvalidConnectProtocolSetting) {
+  DataSavingVisitor visitor;
+  auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);
+
+  const std::string frames = TestFrameSequence()
+                                 .ClientPreface({{ENABLE_CONNECT_PROTOCOL, 3u}})
+                                 .Serialize();
+  testing::InSequence s;
+
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(
+      visitor,
+      OnInvalidFrame(0, Http2VisitorInterface::InvalidFrameError::kProtocol));
+
+  int64_t read_result = adapter->ProcessBytes(frames);
+  EXPECT_EQ(static_cast<size_t>(read_result), frames.size());
+
+  EXPECT_TRUE(adapter->want_write());
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(GOAWAY, 0, _, 0x0));
+  EXPECT_CALL(visitor,
+              OnFrameSent(GOAWAY, 0, _, 0x0,
+                          static_cast<int>(Http2ErrorCode::PROTOCOL_ERROR)));
+
+  int send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
+  EXPECT_THAT(visitor.data(), EqualsFrames({SpdyFrameType::GOAWAY}));
+
+  auto adapter2 = NgHttp2Adapter::CreateServerAdapter(visitor);
+  const std::string frames2 = TestFrameSequence()
+                                  .ClientPreface({{ENABLE_CONNECT_PROTOCOL, 1}})
+                                  .Settings({{ENABLE_CONNECT_PROTOCOL, 0}})
+                                  .Serialize();
+
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  EXPECT_CALL(visitor, OnSetting(Http2Setting{ENABLE_CONNECT_PROTOCOL, 1u}));
+  EXPECT_CALL(visitor, OnSettingsEnd());
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  // Surprisingly, nghttp2 allows this behavior, which is prohibited in RFC
+  // 8441.
+  EXPECT_CALL(visitor, OnSetting(Http2Setting{ENABLE_CONNECT_PROTOCOL, 0u}));
+  EXPECT_CALL(visitor, OnSettingsEnd());
+
+  read_result = adapter2->ProcessBytes(frames2);
+  EXPECT_EQ(static_cast<size_t>(read_result), frames2.size());
+
+  EXPECT_TRUE(adapter2->want_write());
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+  EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+  EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+  EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+  adapter2->Send();
+}
+
 TEST(NgHttp2AdapterTest, ServerForbidsProtocolPseudoheaderBeforeAck) {
   DataSavingVisitor visitor;
   auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);

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

@@ -347,14 +347,14 @@ TEST(OgHttp2AdapterTest, AutomaticPingAcksDisabled) {
               EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::SETTINGS}));
 }
 
-TEST(OgHttp2AdapterTest, InvalidMaxFrameSize) {
+TEST(OgHttp2AdapterTest, InvalidMaxFrameSizeSetting) {
   DataSavingVisitor visitor;
   OgHttp2Adapter::Options options;
   options.perspective = Perspective::kServer;
   auto adapter = OgHttp2Adapter::Create(visitor, options);
 
   const std::string frames =
-      TestFrameSequence().ClientPreface({{MAX_FRAME_SIZE, 3}}).Serialize();
+      TestFrameSequence().ClientPreface({{MAX_FRAME_SIZE, 3u}}).Serialize();
   testing::InSequence s;
 
   // Client preface
@@ -383,6 +383,108 @@ TEST(OgHttp2AdapterTest, InvalidMaxFrameSize) {
               EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::GOAWAY}));
 }
 
+TEST(OgHttp2AdapterTest, InvalidPushSetting) {
+  DataSavingVisitor visitor;
+  OgHttp2Adapter::Options options;
+  options.perspective = Perspective::kServer;
+  auto adapter = OgHttp2Adapter::Create(visitor, options);
+
+  const std::string frames =
+      TestFrameSequence().ClientPreface({{ENABLE_PUSH, 3u}}).Serialize();
+  testing::InSequence s;
+
+  // Client preface
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  EXPECT_CALL(
+      visitor,
+      OnInvalidFrame(0, Http2VisitorInterface::InvalidFrameError::kProtocol));
+  EXPECT_CALL(visitor, OnConnectionError(ConnectionError::kInvalidSetting));
+
+  const int64_t read_result = adapter->ProcessBytes(frames);
+  EXPECT_EQ(static_cast<size_t>(read_result), frames.size());
+
+  EXPECT_TRUE(adapter->want_write());
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x0));
+  EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x0, 0));
+  EXPECT_CALL(visitor, OnBeforeFrameSent(GOAWAY, 0, _, 0x0));
+  EXPECT_CALL(visitor,
+              OnFrameSent(GOAWAY, 0, _, 0x0,
+                          static_cast<int>(Http2ErrorCode::PROTOCOL_ERROR)));
+
+  int send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
+  EXPECT_THAT(visitor.data(),
+              EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::GOAWAY}));
+}
+
+TEST(OgHttp2AdapterTest, InvalidConnectProtocolSetting) {
+  DataSavingVisitor visitor;
+  OgHttp2Adapter::Options options;
+  options.perspective = Perspective::kServer;
+  auto adapter = OgHttp2Adapter::Create(visitor, options);
+
+  const std::string frames = TestFrameSequence()
+                                 .ClientPreface({{ENABLE_CONNECT_PROTOCOL, 3u}})
+                                 .Serialize();
+  testing::InSequence s;
+
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  EXPECT_CALL(
+      visitor,
+      OnInvalidFrame(0, Http2VisitorInterface::InvalidFrameError::kProtocol));
+  EXPECT_CALL(visitor, OnConnectionError(ConnectionError::kInvalidSetting));
+
+  int64_t read_result = adapter->ProcessBytes(frames);
+  EXPECT_EQ(static_cast<size_t>(read_result), frames.size());
+
+  EXPECT_TRUE(adapter->want_write());
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x0));
+  EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x0, 0));
+  EXPECT_CALL(visitor, OnBeforeFrameSent(GOAWAY, 0, _, 0x0));
+  EXPECT_CALL(visitor,
+              OnFrameSent(GOAWAY, 0, _, 0x0,
+                          static_cast<int>(Http2ErrorCode::PROTOCOL_ERROR)));
+
+  int send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
+  EXPECT_THAT(visitor.data(),
+              EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::GOAWAY}));
+
+  auto adapter2 = OgHttp2Adapter::Create(visitor, options);
+  const std::string frames2 = TestFrameSequence()
+                                  .ClientPreface({{ENABLE_CONNECT_PROTOCOL, 1}})
+                                  .Settings({{ENABLE_CONNECT_PROTOCOL, 0}})
+                                  .Serialize();
+
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  EXPECT_CALL(visitor, OnSetting(Http2Setting{ENABLE_CONNECT_PROTOCOL, 1u}));
+  EXPECT_CALL(visitor, OnSettingsEnd());
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  EXPECT_CALL(
+      visitor,
+      OnInvalidFrame(0, Http2VisitorInterface::InvalidFrameError::kProtocol));
+  EXPECT_CALL(visitor, OnConnectionError(ConnectionError::kInvalidSetting));
+
+  read_result = adapter2->ProcessBytes(frames2);
+  EXPECT_EQ(static_cast<size_t>(read_result), frames2.size());
+
+  EXPECT_TRUE(adapter2->want_write());
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x0));
+  EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x0, 0));
+  EXPECT_CALL(visitor, OnBeforeFrameSent(GOAWAY, 0, _, 0x0));
+  EXPECT_CALL(visitor,
+              OnFrameSent(GOAWAY, 0, _, 0x0,
+                          static_cast<int>(Http2ErrorCode::PROTOCOL_ERROR)));
+  adapter2->Send();
+}
+
 TEST(OgHttp2AdapterTest, ClientHandles100Headers) {
   DataSavingVisitor visitor;
   OgHttp2Adapter::Options options;

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

@@ -1233,6 +1233,18 @@ void OgHttp2Session::OnSetting(spdy::SpdySettingsId id, uint32_t value) {
         encoder_header_table_capacity_when_acking_ = value;
       }
       break;
+    case ENABLE_PUSH:
+      if (value > 1u) {
+        visitor_.OnInvalidFrame(
+            0, Http2VisitorInterface::InvalidFrameError::kProtocol);
+        // The specification says this is a connection-level protocol error.
+        LatchErrorAndNotify(
+            Http2ErrorCode::PROTOCOL_ERROR,
+            Http2VisitorInterface::ConnectionError::kInvalidSetting);
+        return;
+      }
+      // Aside from validation, this setting is ignored.
+      break;
     case MAX_CONCURRENT_STREAMS:
       max_outbound_concurrent_streams_ = value;
       if (!IsServerSession()) {
@@ -1266,6 +1278,17 @@ void OgHttp2Session::OnSetting(spdy::SpdySettingsId id, uint32_t value) {
       }
       max_frame_payload_ = value;
       break;
+    case ENABLE_CONNECT_PROTOCOL:
+      if (value > 1u || (value == 0 && peer_enables_connect_protocol_)) {
+        visitor_.OnInvalidFrame(
+            0, Http2VisitorInterface::InvalidFrameError::kProtocol);
+        LatchErrorAndNotify(
+            Http2ErrorCode::PROTOCOL_ERROR,
+            Http2VisitorInterface::ConnectionError::kInvalidSetting);
+        return;
+      }
+      peer_enables_connect_protocol_ = (value == 1u);
+      break;
     default:
       // TODO(bnc): See if C++17 inline constants are allowed in QUICHE.
       if (id == kMetadataExtensionId) {

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

@@ -153,6 +153,9 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
             !goaway_rejected_streams_.empty());
   }
   int GetRemoteWindowSize() const override { return connection_send_window_; }
+  bool peer_enables_connect_protocol() {
+    return peer_enables_connect_protocol_;
+  }
 
   // From SpdyFramerVisitorInterface
   void OnError(http2::Http2DecoderAdapter::SpdyFramerError error,
@@ -508,7 +511,7 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
   int32_t initial_stream_receive_window_ = kInitialFlowControlWindowSize;
   // The initial flow control send window size for any newly created streams.
   int32_t initial_stream_send_window_ = kInitialFlowControlWindowSize;
-  uint32_t max_frame_payload_ = 16384u;
+  uint32_t max_frame_payload_ = kDefaultFramePayloadSizeLimit;
   // The maximum number of concurrent streams that this connection can open to
   // its peer and allow from its peer, respectively. Although the initial value
   // is unlimited, the spec encourages a value of at least 100. We limit
@@ -537,6 +540,8 @@ class QUICHE_EXPORT_PRIVATE OgHttp2Session
   // Recursion guard for Send().
   bool sending_ = false;
 
+  bool peer_enables_connect_protocol_ = false;
+
   // Replace this with a stream ID, for multiple GOAWAY support.
   bool queued_goaway_ = false;
   bool queued_immediate_goaway_ = false;

package/third_party/quiche/quiche/quic/core/congestion_control/send_algorithm_test.cc

@@ -102,22 +102,6 @@ const QuicTime::Delta kTestCellularPropagationDelay =
 const QuicTime::Delta kTestLinkSmallRTTDelay =
     QuicTime::Delta::FromMilliseconds(10);
 
-const char* CongestionControlTypeToString(CongestionControlType cc_type) {
-  switch (cc_type) {
-    case kCubicBytes:
-      return "CUBIC_BYTES";
-    case kRenoBytes:
-      return "RENO_BYTES";
-    case kBBR:
-      return "BBR";
-    case kPCC:
-      return "PCC";
-    default:
-      QUIC_DLOG(FATAL) << "Unexpected CongestionControlType";
-      return nullptr;
-  }
-}
-
 struct TestParams {
   explicit TestParams(CongestionControlType congestion_control_type)
       : congestion_control_type(congestion_control_type) {}

package/third_party/quiche/quiche/quic/core/crypto/crypto_protocol.h

@@ -301,7 +301,7 @@ const QuicTag kNPCO = TAG('N', 'P', 'C', 'O');    // No pacing offload.
 const QuicTag kBWRE = TAG('B', 'W', 'R', 'E');  // Bandwidth resumption.
 const QuicTag kBWMX = TAG('B', 'W', 'M', 'X');  // Max bandwidth resumption.
 const QuicTag kBWID = TAG('B', 'W', 'I', 'D');  // Send bandwidth when idle.
-const QuicTag kBWR1 = TAG('B', 'W', 'I', '1');  // Resume bandwidth experiment 1
+const QuicTag kBWI1 = TAG('B', 'W', 'I', '1');  // Resume bandwidth experiment 1
 const QuicTag kBWRS = TAG('B', 'W', 'R', 'S');  // Server bandwidth resumption.
 const QuicTag kBWS2 = TAG('B', 'W', 'S', '2');  // Server bw resumption v2.
 const QuicTag kBWS3 = TAG('B', 'W', 'S', '3');  // QUIC Initial CWND - Control.

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

@@ -201,6 +201,7 @@ class EndToEndTest : public QuicTestWithParam<TestParams> {
         connect_to_server_on_initialize_(true),
         server_address_(QuicSocketAddress(TestLoopback(), 0)),
         server_hostname_("test.example.com"),
+        fd_(kQuicInvalidSocketFd),
         client_writer_(nullptr),
         server_writer_(nullptr),
         version_(GetParam().version),
@@ -464,10 +465,24 @@ class EndToEndTest : public QuicTestWithParam<TestParams> {
     } else {
       ADD_FAILURE() << "Missing client connection";
     }
-    StopServer();
+    StopServer(/*will_restart=*/false);
+    if (fd_ != kQuicInvalidSocketFd) {
+      // Every test should follow StopServer(true) with StartServer(), so we
+      // should never get here.
+      QuicUdpSocketApi socket_api;
+      socket_api.Destroy(fd_);
+      fd_ = kQuicInvalidSocketFd;
+    }
   }
 
   void StartServer() {
+    if (fd_ != kQuicInvalidSocketFd) {
+      // We previously called StopServer to reserve the ephemeral port. Close
+      // the socket so that it's available below.
+      QuicUdpSocketApi socket_api;
+      socket_api.Destroy(fd_);
+      fd_ = kQuicInvalidSocketFd;
+    }
     auto test_server = std::make_unique<QuicTestServer>(
         crypto_test_utils::ProofSourceForTesting(), server_config_,
         server_supported_versions_, &memory_cache_backend_,
@@ -485,6 +500,7 @@ class EndToEndTest : public QuicTestWithParam<TestParams> {
         QuicSocketAddress(server_address_.host(), server_thread_->GetPort());
     QuicDispatcher* dispatcher =
         QuicServerPeer::GetDispatcher(server_thread_->server());
+    ASSERT_TRUE(dispatcher != nullptr);
     QuicDispatcherPeer::UseWriter(dispatcher, server_writer_);
 
     server_writer_->Initialize(QuicDispatcherPeer::GetHelper(dispatcher),
@@ -498,11 +514,30 @@ class EndToEndTest : public QuicTestWithParam<TestParams> {
     server_thread_->Start();
   }
 
-  void StopServer() {
+  void StopServer(bool will_restart = true) {
     if (server_thread_) {
       server_thread_->Quit();
       server_thread_->Join();
     }
+    if (will_restart) {
+      // server_address_ now contains the random listening port. Since many
+      // tests will attempt to re-bind the socket, claim it so that the kernel
+      // doesn't give away the ephemeral port.
+      QuicUdpSocketApi socket_api;
+      fd_ = socket_api.Create(
+          server_address_.host().AddressFamilyToInt(),
+          /*receive_buffer_size =*/kDefaultSocketReceiveBuffer,
+          /*send_buffer_size =*/kDefaultSocketReceiveBuffer);
+      if (fd_ == kQuicInvalidSocketFd) {
+        QUIC_LOG(ERROR) << "CreateSocket() failed: " << strerror(errno);
+        return;
+      }
+      int rc = socket_api.Bind(fd_, server_address_);
+      if (rc < 0) {
+        QUIC_LOG(ERROR) << "Bind failed: " << strerror(errno);
+        return;
+      }
+    }
   }
 
   void AddToCache(absl::string_view path, int response_code,
@@ -834,6 +869,9 @@ class EndToEndTest : public QuicTestWithParam<TestParams> {
   std::string server_hostname_;
   QuicTestBackend memory_cache_backend_;
   std::unique_ptr<ServerThread> server_thread_;
+  // This socket keeps the ephemeral port reserved so that the kernel doesn't
+  // give it away while the server is shut down.
+  QuicUdpSocketFd fd_;
   std::unique_ptr<QuicTestClient> client_;
   QuicConnectionDebugVisitor* connection_debug_visitor_ = nullptr;
   PacketDroppingTestWriter* client_writer_;
@@ -5950,6 +5988,10 @@ TEST_P(EndToEndTest, CustomTransportParameters) {
 }
 
 TEST_P(EndToEndTest, LegacyVersionEncapsulation) {
+  if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
+    ASSERT_TRUE(Initialize());
+    return;
+  }
   if (!version_.HasLongHeaderLengths() ||
       override_server_connection_id_length_ > -1) {
     // Decapsulating Legacy Version Encapsulation packets from these versions
@@ -5968,6 +6010,10 @@ TEST_P(EndToEndTest, LegacyVersionEncapsulation) {
 }
 
 TEST_P(EndToEndTest, LegacyVersionEncapsulationWithMultiPacketChlo) {
+  if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
+    ASSERT_TRUE(Initialize());
+    return;
+  }
   if (!version_.HasLongHeaderLengths() ||
       override_server_connection_id_length_ > -1) {
     // Decapsulating Legacy Version Encapsulation packets from these versions
@@ -5996,6 +6042,10 @@ TEST_P(EndToEndTest, LegacyVersionEncapsulationWithMultiPacketChlo) {
 }
 
 TEST_P(EndToEndTest, LegacyVersionEncapsulationWithVersionNegotiation) {
+  if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
+    ASSERT_TRUE(Initialize());
+    return;
+  }
   if (!version_.HasLongHeaderLengths() ||
       override_server_connection_id_length_ > -1) {
     // Decapsulating Legacy Version Encapsulation packets from these versions
@@ -6016,6 +6066,10 @@ TEST_P(EndToEndTest, LegacyVersionEncapsulationWithVersionNegotiation) {
 }
 
 TEST_P(EndToEndTest, LegacyVersionEncapsulationWithLoss) {
+  if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
+    ASSERT_TRUE(Initialize());
+    return;
+  }
   if (!version_.HasLongHeaderLengths() ||
       override_server_connection_id_length_ > -1) {
     // Decapsulating Legacy Version Encapsulation packets from these versions

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

@@ -21,6 +21,7 @@ std::string H3SettingsToString(Http3AndQpackSettingsIdentifiers identifier) {
     RETURN_STRING_LITERAL(SETTINGS_H3_DATAGRAM_DRAFT09);
     RETURN_STRING_LITERAL(SETTINGS_WEBTRANS_DRAFT00);
     RETURN_STRING_LITERAL(SETTINGS_ENABLE_CONNECT_PROTOCOL);
+    RETURN_STRING_LITERAL(SETTINGS_ENABLE_METADATA);
   }
   return absl::StrCat("UNSUPPORTED_SETTINGS_TYPE(", identifier, ")");
 }

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

@@ -46,6 +46,7 @@ enum Http3AndQpackSettingsIdentifiers : uint64_t {
   SETTINGS_WEBTRANS_DRAFT00 = 0x2b603742,
   // draft-ietf-httpbis-h3-websockets
   SETTINGS_ENABLE_CONNECT_PROTOCOL = 0x08,
+  SETTINGS_ENABLE_METADATA = 0x4d44,
 };
 
 // Returns HTTP/3 SETTINGS identifier as a string.

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

@@ -33,7 +33,6 @@ QuicByteCount GetTotalLength(QuicByteCount payload_length, HttpFrameType type) {
 
 }  // namespace
 
-// static
 QuicByteCount HttpEncoder::GetDataFrameHeaderLength(
     QuicByteCount payload_length) {
   QUICHE_DCHECK_NE(0u, payload_length);
@@ -42,7 +41,6 @@ QuicByteCount HttpEncoder::GetDataFrameHeaderLength(
              static_cast<uint64_t>(HttpFrameType::DATA));
 }
 
-// static
 quiche::QuicheBuffer HttpEncoder::SerializeDataFrameHeader(
     QuicByteCount payload_length, quiche::QuicheBufferAllocator* allocator) {
   QUICHE_DCHECK_NE(0u, payload_length);
@@ -59,7 +57,6 @@ quiche::QuicheBuffer HttpEncoder::SerializeDataFrameHeader(
   return quiche::QuicheBuffer();
 }
 
-// static
 QuicByteCount HttpEncoder::SerializeHeadersFrameHeader(
     QuicByteCount payload_length, std::unique_ptr<char[]>* output) {
   QUICHE_DCHECK_NE(0u, payload_length);
@@ -68,7 +65,7 @@ QuicByteCount HttpEncoder::SerializeHeadersFrameHeader(
       QuicDataWriter::GetVarInt62Len(
           static_cast<uint64_t>(HttpFrameType::HEADERS));
 
-  output->reset(new char[header_length]);
+  *output = std::make_unique<char[]>(header_length);
   QuicDataWriter writer(header_length, output->get());
 
   if (WriteFrameHeader(payload_length, HttpFrameType::HEADERS, &writer)) {
@@ -80,7 +77,6 @@ QuicByteCount HttpEncoder::SerializeHeadersFrameHeader(
   return 0;
 }
 
-// static
 QuicByteCount HttpEncoder::SerializeSettingsFrame(
     const SettingsFrame& settings, std::unique_ptr<char[]>* output) {
   QuicByteCount payload_length = 0;
@@ -96,7 +92,7 @@ QuicByteCount HttpEncoder::SerializeSettingsFrame(
   QuicByteCount total_length =
       GetTotalLength(payload_length, HttpFrameType::SETTINGS);
 
-  output->reset(new char[total_length]);
+  *output = std::make_unique<char[]>(total_length);
   QuicDataWriter writer(total_length, output->get());
 
   if (!WriteFrameHeader(payload_length, HttpFrameType::SETTINGS, &writer)) {
@@ -116,14 +112,13 @@ QuicByteCount HttpEncoder::SerializeSettingsFrame(
   return total_length;
 }
 
-// static
 QuicByteCount HttpEncoder::SerializeGoAwayFrame(
     const GoAwayFrame& goaway, std::unique_ptr<char[]>* output) {
   QuicByteCount payload_length = QuicDataWriter::GetVarInt62Len(goaway.id);
   QuicByteCount total_length =
       GetTotalLength(payload_length, HttpFrameType::GOAWAY);
 
-  output->reset(new char[total_length]);
+  *output = std::make_unique<char[]>(total_length);
   QuicDataWriter writer(total_length, output->get());
 
   if (WriteFrameHeader(payload_length, HttpFrameType::GOAWAY, &writer) &&
@@ -135,7 +130,6 @@ QuicByteCount HttpEncoder::SerializeGoAwayFrame(
   return 0;
 }
 
-// static
 QuicByteCount HttpEncoder::SerializePriorityUpdateFrame(
     const PriorityUpdateFrame& priority_update,
     std::unique_ptr<char[]>* output) {
@@ -151,7 +145,7 @@ QuicByteCount HttpEncoder::SerializePriorityUpdateFrame(
   QuicByteCount total_length = GetTotalLength(
       payload_length, HttpFrameType::PRIORITY_UPDATE_REQUEST_STREAM);
 
-  output->reset(new char[total_length]);
+  *output = std::make_unique<char[]>(total_length);
   QuicDataWriter writer(total_length, output->get());
 
   if (WriteFrameHeader(payload_length,
@@ -168,7 +162,6 @@ QuicByteCount HttpEncoder::SerializePriorityUpdateFrame(
   return 0;
 }
 
-// static
 QuicByteCount HttpEncoder::SerializeAcceptChFrame(
     const AcceptChFrame& accept_ch, std::unique_ptr<char[]>* output) {
   QuicByteCount payload_length = 0;
@@ -182,7 +175,7 @@ QuicByteCount HttpEncoder::SerializeAcceptChFrame(
   QuicByteCount total_length =
       GetTotalLength(payload_length, HttpFrameType::ACCEPT_CH);
 
-  output->reset(new char[total_length]);
+  *output = std::make_unique<char[]>(total_length);
   QuicDataWriter writer(total_length, output->get());
 
   if (!WriteFrameHeader(payload_length, HttpFrameType::ACCEPT_CH, &writer)) {
@@ -203,7 +196,6 @@ QuicByteCount HttpEncoder::SerializeAcceptChFrame(
   return total_length;
 }
 
-// static
 QuicByteCount HttpEncoder::SerializeGreasingFrame(
     std::unique_ptr<char[]>* output) {
   uint64_t frame_type;
@@ -222,16 +214,15 @@ QuicByteCount HttpEncoder::SerializeGreasingFrame(
     payload_length = result % 4;
 
     if (payload_length > 0) {
-      std::unique_ptr<char[]> buffer(new char[payload_length]);
-      QuicRandom::GetInstance()->RandBytes(buffer.get(), payload_length);
-      payload = std::string(buffer.get(), payload_length);
+      payload.resize(payload_length);
+      QuicRandom::GetInstance()->RandBytes(payload.data(), payload_length);
     }
   }
   QuicByteCount total_length = QuicDataWriter::GetVarInt62Len(frame_type) +
                                QuicDataWriter::GetVarInt62Len(payload_length) +
                                payload_length;
 
-  output->reset(new char[total_length]);
+  *output = std::make_unique<char[]>(total_length);
   QuicDataWriter writer(total_length, output->get());
 
   bool success =
@@ -270,4 +261,24 @@ QuicByteCount HttpEncoder::SerializeWebTransportStreamFrameHeader(
   return 0;
 }
 
+QuicByteCount HttpEncoder::SerializeMetadataFrameHeader(
+    QuicByteCount payload_length, std::unique_ptr<char[]>* output) {
+  QUICHE_DCHECK_NE(0u, payload_length);
+  QuicByteCount header_length =
+      QuicDataWriter::GetVarInt62Len(payload_length) +
+      QuicDataWriter::GetVarInt62Len(
+          static_cast<uint64_t>(HttpFrameType::METADATA));
+
+  *output = std::make_unique<char[]>(header_length);
+  QuicDataWriter writer(header_length, output->get());
+
+  if (WriteFrameHeader(payload_length, HttpFrameType::METADATA, &writer)) {
+    return header_length;
+  }
+  QUIC_DLOG(ERROR)
+      << "Http encoder failed when attempting to serialize METADATA "
+         "frame header.";
+  return 0;
+}
+
 }  // namespace quic

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

@@ -65,6 +65,11 @@ class QUIC_EXPORT_PRIVATE HttpEncoder {
   // https://www.ietf.org/archive/id/draft-ietf-webtrans-http3-00.html#name-client-initiated-bidirectio
   static QuicByteCount SerializeWebTransportStreamFrameHeader(
       WebTransportSessionId session_id, std::unique_ptr<char[]>* output);
+
+  // Serializes a METADATA frame header into a new buffer stored in |output|.
+  // Returns the length of the buffer on success, or 0 otherwise.
+  static QuicByteCount SerializeMetadataFrameHeader(
+      QuicByteCount payload_length, std::unique_ptr<char[]>* output);
 };
 
 }  // namespace quic