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

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

@@ -278,7 +278,6 @@ size_t QuicSpdyStream::WriteHeaders(
   MaybeProcessSentWebTransportHeaders(header_block);
 
   if (web_transport_ != nullptr &&
-      spdy_session_->http_datagram_support() != HttpDatagramSupport::kDraft00 &&
       spdy_session_->perspective() == Perspective::IS_SERVER) {
     header_block["sec-webtransport-http3-draft"] = "draft02";
   }
@@ -296,24 +295,20 @@ size_t QuicSpdyStream::WriteHeaders(
 
   if (web_transport_ != nullptr &&
       session()->perspective() == Perspective::IS_CLIENT) {
-    if (spdy_session_->http_datagram_support() !=
-        HttpDatagramSupport::kDraft00) {
-      // draft-ietf-masque-h3-datagram-01 and later use capsules.
+    WriteGreaseCapsule();
+    if (spdy_session_->http_datagram_support() ==
+        HttpDatagramSupport::kDraft04) {
+      // Send a REGISTER_DATAGRAM_NO_CONTEXT capsule to support servers that
+      // are running draft-ietf-masque-h3-datagram-04 or -05.
+      uint64_t capsule_type = 0xff37a2;  // REGISTER_DATAGRAM_NO_CONTEXT
+      constexpr unsigned char capsule_data[4] = {
+          0x80, 0xff, 0x7c, 0x00,  // WEBTRANSPORT datagram format type
+      };
+      WriteCapsule(Capsule::Unknown(
+          capsule_type,
+          absl::string_view(reinterpret_cast<const char*>(capsule_data),
+                            sizeof(capsule_data))));
       WriteGreaseCapsule();
-      if (spdy_session_->http_datagram_support() ==
-          HttpDatagramSupport::kDraft04) {
-        // Send a REGISTER_DATAGRAM_NO_CONTEXT capsule to support servers that
-        // are running draft-ietf-masque-h3-datagram-04 or -05.
-        uint64_t capsule_type = 0xff37a2;  // REGISTER_DATAGRAM_NO_CONTEXT
-        constexpr unsigned char capsule_data[4] = {
-            0x80, 0xff, 0x7c, 0x00,  // WEBTRANSPORT datagram format type
-        };
-        WriteCapsule(Capsule::Unknown(
-            capsule_type,
-            absl::string_view(reinterpret_cast<const char*>(capsule_data),
-                              sizeof(capsule_data))));
-        WriteGreaseCapsule();
-      }
     }
   }
 
@@ -759,18 +754,20 @@ void QuicSpdyStream::OnStreamReset(const QuicRstStreamFrame& frame) {
     return;
   }
 
-  if (GetQuicReloadableFlag(quic_fix_on_stream_reset) &&
-      VersionUsesHttp3(transport_version())) {
-    QUIC_RELOADABLE_FLAG_COUNT(quic_fix_on_stream_reset);
-    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;
-    }
+  if (VersionUsesHttp3(transport_version())) {
+    QUIC_CODE_COUNT(quic_fix_on_stream_reset);
+    if (GetQuicReloadableFlag(quic_fix_on_stream_reset)) {
+      QUIC_RELOADABLE_FLAG_COUNT(quic_fix_on_stream_reset);
+      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);
-    return;
+      QuicStream::OnStreamReset(frame);
+      return;
+    }
   }
 
   QUIC_DVLOG(1) << ENDPOINT
@@ -904,10 +901,6 @@ void QuicSpdyStream::OnClose() {
     visitor->OnClose(this);
   }
 
-  if (datagram_flow_id_.has_value()) {
-    spdy_session_->UnregisterHttp3DatagramFlowId(datagram_flow_id_.value());
-  }
-
   if (web_transport_ != nullptr) {
     web_transport_->OnConnectStreamClosing();
   }
@@ -1259,8 +1252,6 @@ void QuicSpdyStream::MaybeProcessReceivedWebTransportHeaders() {
 
   std::string method;
   std::string protocol;
-  absl::optional<QuicDatagramStreamId> flow_id;
-  bool version_indicated = false;
   for (const auto& [header_name, header_value] : header_list_) {
     if (header_name == ":method") {
       if (!method.empty() || header_value.empty()) {
@@ -1275,21 +1266,10 @@ void QuicSpdyStream::MaybeProcessReceivedWebTransportHeaders() {
       protocol = header_value;
     }
     if (header_name == "datagram-flow-id") {
-      if (spdy_session_->http_datagram_support() !=
-          HttpDatagramSupport::kDraft00) {
-        QUIC_DLOG(ERROR) << ENDPOINT
-                         << "Rejecting WebTransport due to unexpected "
-                            "Datagram-Flow-Id header";
-        return;
-      }
-      if (flow_id.has_value() || header_value.empty()) {
-        return;
-      }
-      QuicDatagramStreamId flow_id_out;
-      if (!absl::SimpleAtoi(header_value, &flow_id_out)) {
-        return;
-      }
-      flow_id = flow_id_out;
+      QUIC_DLOG(ERROR) << ENDPOINT
+                       << "Rejecting WebTransport due to unexpected "
+                          "Datagram-Flow-Id header";
+      return;
     }
     if (header_name == "sec-webtransport-http3-draft02") {
       if (header_value != "1") {
@@ -1298,7 +1278,6 @@ void QuicSpdyStream::MaybeProcessReceivedWebTransportHeaders() {
                             "Sec-Webtransport-Http3-Draft02 header";
         return;
       }
-      version_indicated = true;
     }
   }
 
@@ -1306,24 +1285,6 @@ void QuicSpdyStream::MaybeProcessReceivedWebTransportHeaders() {
     return;
   }
 
-  if (!version_indicated &&
-      spdy_session_->http_datagram_support() != HttpDatagramSupport::kDraft00) {
-    QUIC_DLOG(ERROR)
-        << ENDPOINT
-        << "WebTransport request rejected due to missing version header.";
-    return;
-  }
-
-  if (spdy_session_->http_datagram_support() == HttpDatagramSupport::kDraft00) {
-    if (!flow_id.has_value()) {
-      QUIC_DLOG(ERROR)
-          << ENDPOINT
-          << "Rejecting WebTransport due to missing Datagram-Flow-Id header";
-      return;
-    }
-    RegisterHttp3DatagramFlowId(*flow_id);
-  }
-
   web_transport_ =
       std::make_unique<WebTransportHttp3>(spdy_session_, this, id());
 }
@@ -1347,11 +1308,7 @@ void QuicSpdyStream::MaybeProcessSentWebTransportHeaders(
     return;
   }
 
-  if (spdy_session_->http_datagram_support() == HttpDatagramSupport::kDraft00) {
-    headers["datagram-flow-id"] = absl::StrCat(id());
-  } else {
-    headers["sec-webtransport-http3-draft02"] = "1";
-  }
+  headers["sec-webtransport-http3-draft02"] = "1";
 
   web_transport_ =
       std::make_unique<WebTransportHttp3>(spdy_session_, this, id());
@@ -1491,9 +1448,7 @@ void QuicSpdyStream::WriteGreaseCapsule() {
 }
 
 MessageStatus QuicSpdyStream::SendHttp3Datagram(absl::string_view payload) {
-  QuicDatagramStreamId stream_id =
-      datagram_flow_id_.has_value() ? datagram_flow_id_.value() : id();
-  return spdy_session_->SendHttp3Datagram(stream_id, payload);
+  return spdy_session_->SendHttp3Datagram(id(), payload);
 }
 
 void QuicSpdyStream::RegisterHttp3DatagramVisitor(
@@ -1555,20 +1510,13 @@ void QuicSpdyStream::OnDatagramReceived(QuicDataReader* reader) {
 QuicByteCount QuicSpdyStream::GetMaxDatagramSize() const {
   QuicByteCount prefix_size = 0;
   switch (spdy_session_->http_datagram_support()) {
-    case HttpDatagramSupport::kDraft00:
-      if (!datagram_flow_id_.has_value()) {
-        QUIC_BUG(GetMaxDatagramSize with no flow ID)
-            << "GetMaxDatagramSize() called when no flow ID available";
-        break;
-      }
-      prefix_size = QuicDataWriter::GetVarInt62Len(*datagram_flow_id_);
-      break;
     case HttpDatagramSupport::kDraft04:
+    case HttpDatagramSupport::kDraft09:
       prefix_size =
           QuicDataWriter::GetVarInt62Len(id() / kHttpDatagramStreamIdDivisor);
       break;
     case HttpDatagramSupport::kNone:
-    case HttpDatagramSupport::kDraft00And04:
+    case HttpDatagramSupport::kDraft04And09:
       QUIC_BUG(GetMaxDatagramSize called with no datagram support)
           << "GetMaxDatagramSize() called when no HTTP/3 datagram support has "
              "been negotiated.  Support value: "
@@ -1591,11 +1539,6 @@ QuicByteCount QuicSpdyStream::GetMaxDatagramSize() const {
   return max_datagram_size - prefix_size;
 }
 
-void QuicSpdyStream::RegisterHttp3DatagramFlowId(QuicDatagramStreamId flow_id) {
-  datagram_flow_id_ = flow_id;
-  spdy_session_->RegisterHttp3DatagramFlowId(datagram_flow_id_.value(), id());
-}
-
 void QuicSpdyStream::HandleBodyAvailable() {
   if (!capsule_parser_) {
     OnBodyAvailable();

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

@@ -262,8 +262,7 @@ class QUIC_EXPORT_PRIVATE QuicSpdyStream
     virtual ~Http3DatagramVisitor() {}
 
     // Called when an HTTP/3 datagram is received. |payload| does not contain
-    // the stream ID. Note that this contains the stream ID even if flow IDs
-    // from draft-ietf-masque-h3-datagram-00 are in use.
+    // the stream ID.
     virtual void OnHttp3Datagram(QuicStreamId stream_id,
                                  absl::string_view payload) = 0;
   };
@@ -285,10 +284,6 @@ class QUIC_EXPORT_PRIVATE QuicSpdyStream
 
   void OnDatagramReceived(QuicDataReader* reader);
 
-  // Registers a datagram flow ID, only meant to be used when in legacy mode for
-  // draft-ietf-masque-h3-datagram-00.
-  void RegisterHttp3DatagramFlowId(QuicDatagramStreamId flow_id);
-
   QuicByteCount GetMaxDatagramSize() const;
 
   // Writes |capsule| onto the DATA stream.
@@ -467,9 +462,6 @@ class QUIC_EXPORT_PRIVATE QuicSpdyStream
 
   // HTTP/3 Datagram support.
   Http3DatagramVisitor* datagram_visitor_ = nullptr;
-  // Flow ID is only used when in legacy mode for
-  // draft-ietf-masque-h3-datagram-00.
-  absl::optional<QuicDatagramStreamId> datagram_flow_id_;
 };
 
 }  // namespace quic

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

@@ -192,6 +192,21 @@ class TestCryptoStream : public QuicCryptoStream, public QuicCryptoHandshaker {
     return level != ENCRYPTION_ZERO_RTT;
   }
 
+  EncryptionLevel GetEncryptionLevelToSendCryptoDataOfSpace(
+      PacketNumberSpace space) const override {
+    switch (space) {
+      case INITIAL_DATA:
+        return ENCRYPTION_INITIAL;
+      case HANDSHAKE_DATA:
+        return ENCRYPTION_HANDSHAKE;
+      case APPLICATION_DATA:
+        return ENCRYPTION_FORWARD_SECURE;
+      default:
+        QUICHE_DCHECK(false);
+        return NUM_ENCRYPTION_LEVELS;
+    }
+  }
+
  private:
   using QuicCryptoStream::session;
 
@@ -984,7 +999,7 @@ TEST_P(QuicSpdyStreamTest, StreamFlowControlBlocked) {
   }
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kWindow - kHeaderLength, true)));
-  EXPECT_CALL(*session_, SendBlocked(_));
+  EXPECT_CALL(*session_, SendBlocked(_, _));
   EXPECT_CALL(*connection_, SendControlFrame(_));
   stream_->WriteOrBufferBody(body, false);
 
@@ -1239,7 +1254,8 @@ TEST_P(QuicSpdyStreamTest, StreamFlowControlFinNotBlocked) {
   std::string body = "";
   bool fin = true;
 
-  EXPECT_CALL(*session_, SendBlocked(GetNthClientInitiatedBidirectionalId(0)))
+  EXPECT_CALL(*session_,
+              SendBlocked(GetNthClientInitiatedBidirectionalId(0), _))
       .Times(0);
   EXPECT_CALL(*session_, WritevData(_, 0, _, FIN, _, _));
 
@@ -3060,39 +3076,13 @@ TEST_P(QuicSpdyStreamTest, TwoResetStreamFrames) {
   }
 }
 
-TEST_P(QuicSpdyStreamTest, ProcessOutgoingWebTransportHeadersDatagramDraft00) {
-  if (!UsesHttp3()) {
-    return;
-  }
-
-  InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
-  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft00And04);
-  session_->EnableWebTransport();
-  session_->OnSetting(SETTINGS_ENABLE_CONNECT_PROTOCOL, 1);
-  QuicSpdySessionPeer::EnableWebTransport(session_.get());
-  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
-                                              HttpDatagramSupport::kDraft00);
-
-  EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  EXPECT_CALL(*session_, WritevData(stream_->id(), _, _, _, _, _))
-      .Times(AnyNumber());
-
-  spdy::SpdyHeaderBlock headers;
-  headers[":method"] = "CONNECT";
-  headers[":protocol"] = "webtransport";
-  headers["datagram-flow-id"] = absl::StrCat(stream_->id());
-  stream_->WriteHeaders(std::move(headers), /*fin=*/false, nullptr);
-  ASSERT_TRUE(stream_->web_transport() != nullptr);
-  EXPECT_EQ(stream_->id(), stream_->web_transport()->id());
-}
-
 TEST_P(QuicSpdyStreamTest, ProcessOutgoingWebTransportHeadersDatagramDraft04) {
   if (!UsesHttp3()) {
     return;
   }
 
   InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
-  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft00And04);
+  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft04);
   session_->EnableWebTransport();
   session_->OnSetting(SETTINGS_ENABLE_CONNECT_PROTOCOL, 1);
   QuicSpdySessionPeer::EnableWebTransport(session_.get());
@@ -3117,7 +3107,7 @@ TEST_P(QuicSpdyStreamTest, ProcessIncomingWebTransportHeadersDatagramDraft04) {
   }
 
   Initialize(kShouldProcessData);
-  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft00And04);
+  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft04);
   session_->EnableWebTransport();
   QuicSpdySessionPeer::EnableWebTransport(session_.get());
   QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
@@ -3137,111 +3127,14 @@ TEST_P(QuicSpdyStreamTest, ProcessIncomingWebTransportHeadersDatagramDraft04) {
   EXPECT_EQ(stream_->id(), stream_->web_transport()->id());
 }
 
-TEST_P(QuicSpdyStreamTest, ProcessIncomingWebTransportHeadersDatagramDraft00) {
-  if (!UsesHttp3()) {
-    return;
-  }
-
-  Initialize(kShouldProcessData);
-  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft00And04);
-  session_->EnableWebTransport();
-  QuicSpdySessionPeer::EnableWebTransport(session_.get());
-  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
-                                              HttpDatagramSupport::kDraft00);
-
-  headers_[":method"] = "CONNECT";
-  headers_[":protocol"] = "webtransport";
-  headers_["datagram-flow-id"] = absl::StrCat(stream_->id());
-
-  stream_->OnStreamHeadersPriority(
-      spdy::SpdyStreamPrecedence(kV3HighestPriority));
-  ProcessHeaders(false, headers_);
-  EXPECT_EQ("", stream_->data());
-  EXPECT_FALSE(stream_->header_list().empty());
-  EXPECT_FALSE(stream_->IsDoneReading());
-  ASSERT_TRUE(stream_->web_transport() != nullptr);
-  EXPECT_EQ(stream_->id(), stream_->web_transport()->id());
-}
-
-TEST_P(QuicSpdyStreamTest,
-       ProcessIncomingWebTransportHeadersWithMismatchedFlowId) {
-  if (!UsesHttp3()) {
-    return;
-  }
-  // TODO(b/181256914) Remove this test when we deprecate
-  // draft-ietf-masque-h3-datagram-00 in favor of later drafts.
-
-  Initialize(kShouldProcessData);
-  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft00And04);
-  session_->EnableWebTransport();
-  QuicSpdySessionPeer::EnableWebTransport(session_.get());
-  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
-                                              HttpDatagramSupport::kDraft00);
-
-  headers_[":method"] = "CONNECT";
-  headers_[":protocol"] = "webtransport";
-  headers_["datagram-flow-id"] = "2";
-
-  stream_->OnStreamHeadersPriority(
-      spdy::SpdyStreamPrecedence(kV3HighestPriority));
-  ProcessHeaders(false, headers_);
-  EXPECT_EQ("", stream_->data());
-  EXPECT_FALSE(stream_->header_list().empty());
-  EXPECT_FALSE(stream_->IsDoneReading());
-  ASSERT_TRUE(stream_->web_transport() != nullptr);
-  EXPECT_EQ(stream_->id(), stream_->web_transport()->id());
-}
-
-TEST_P(QuicSpdyStreamTest, ReceiveHttpDatagramDraft00) {
-  if (!UsesHttp3()) {
-    return;
-  }
-  InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
-  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft00And04);
-  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
-                                              HttpDatagramSupport::kDraft00);
-  headers_[":method"] = "CONNECT";
-  headers_[":protocol"] = "webtransport";
-  headers_["datagram-flow-id"] = absl::StrCat(stream_->id());
-  ProcessHeaders(false, headers_);
-  session_->RegisterHttp3DatagramFlowId(stream_->id(), stream_->id());
-  SavingHttp3DatagramVisitor h3_datagram_visitor;
-  ASSERT_EQ(QuicDataWriter::GetVarInt62Len(stream_->id()), 1);
-  std::array<char, 256> datagram;
-  datagram[0] = stream_->id();
-  for (size_t i = 1; i < datagram.size(); i++) {
-    datagram[i] = i;
-  }
-  stream_->RegisterHttp3DatagramVisitor(&h3_datagram_visitor);
-  session_->OnMessageReceived(
-      absl::string_view(datagram.data(), datagram.size()));
-  EXPECT_THAT(
-      h3_datagram_visitor.received_h3_datagrams(),
-      ElementsAre(SavingHttp3DatagramVisitor::SavedHttp3Datagram{
-          stream_->id(), std::string(&datagram[1], datagram.size() - 1)}));
-  // Test move.
-  SavingHttp3DatagramVisitor h3_datagram_visitor2;
-  stream_->ReplaceHttp3DatagramVisitor(&h3_datagram_visitor2);
-  EXPECT_TRUE(h3_datagram_visitor2.received_h3_datagrams().empty());
-  session_->OnMessageReceived(
-      absl::string_view(datagram.data(), datagram.size()));
-  EXPECT_THAT(
-      h3_datagram_visitor2.received_h3_datagrams(),
-      ElementsAre(SavingHttp3DatagramVisitor::SavedHttp3Datagram{
-          stream_->id(), std::string(&datagram[1], datagram.size() - 1)}));
-  // Cleanup.
-  stream_->UnregisterHttp3DatagramVisitor();
-  session_->UnregisterHttp3DatagramFlowId(stream_->id());
-}
-
-TEST_P(QuicSpdyStreamTest, ReceiveHttpDatagramDraft04) {
+TEST_P(QuicSpdyStreamTest, ReceiveHttpDatagram) {
   if (!UsesHttp3()) {
     return;
   }
   InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
-  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft04);
+  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft09);
   QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
-                                              HttpDatagramSupport::kDraft04);
+                                              HttpDatagramSupport::kDraft09);
   headers_[":method"] = "CONNECT";
   headers_[":protocol"] = "webtransport";
   ProcessHeaders(false, headers_);
@@ -3279,9 +3172,9 @@ TEST_P(QuicSpdyStreamTest, SendHttpDatagram) {
     return;
   }
   Initialize(kShouldProcessData);
-  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft00And04);
+  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft09);
   QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
-                                              HttpDatagramSupport::kDraft04);
+                                              HttpDatagramSupport::kDraft09);
   std::string http_datagram_payload = {1, 2, 3, 4, 5, 6};
   EXPECT_CALL(*connection_, SendMessage(1, _, false))
       .WillOnce(Return(MESSAGE_STATUS_SUCCESS));
@@ -3294,9 +3187,9 @@ TEST_P(QuicSpdyStreamTest, GetMaxDatagramSize) {
     return;
   }
   Initialize(kShouldProcessData);
-  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft00And04);
+  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft09);
   QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
-                                              HttpDatagramSupport::kDraft04);
+                                              HttpDatagramSupport::kDraft09);
   EXPECT_GT(stream_->GetMaxDatagramSize(), 512u);
 }
 

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

@@ -154,47 +154,6 @@ bool SpdyUtils::PopulateHeaderBlockFromUrl(const std::string url,
   return true;
 }
 
-// static
-absl::optional<QuicDatagramStreamId> SpdyUtils::ParseDatagramFlowIdHeader(
-    const spdy::SpdyHeaderBlock& headers) {
-  auto flow_id_pair = headers.find("datagram-flow-id");
-  if (flow_id_pair == headers.end()) {
-    return absl::nullopt;
-  }
-  std::vector<absl::string_view> flow_id_strings =
-      absl::StrSplit(flow_id_pair->second, ',');
-  absl::optional<QuicDatagramStreamId> first_named_flow_id;
-  for (absl::string_view flow_id_string : flow_id_strings) {
-    std::vector<absl::string_view> flow_id_components =
-        absl::StrSplit(flow_id_string, ';');
-    if (flow_id_components.empty()) {
-      continue;
-    }
-    absl::string_view flow_id_value_string = flow_id_components[0];
-    quiche::QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(
-        &flow_id_value_string);
-    QuicDatagramStreamId flow_id;
-    if (!absl::SimpleAtoi(flow_id_value_string, &flow_id)) {
-      continue;
-    }
-    if (flow_id_components.size() == 1) {
-      // This flow ID is unnamed, return this one.
-      return flow_id;
-    }
-    // Otherwise this is a named flow ID.
-    if (!first_named_flow_id.has_value()) {
-      first_named_flow_id = flow_id;
-    }
-  }
-  return first_named_flow_id;
-}
-
-// static
-void SpdyUtils::AddDatagramFlowIdHeader(spdy::SpdyHeaderBlock* headers,
-                                        QuicDatagramStreamId flow_id) {
-  (*headers)["datagram-flow-id"] = absl::StrCat(flow_id);
-}
-
 // static
 ParsedQuicVersion SpdyUtils::ExtractQuicVersionFromAltSvcEntry(
     const spdy::SpdyAltSvcWireFormat::AlternativeService&

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

@@ -54,15 +54,6 @@ class QUIC_EXPORT_PRIVATE SpdyUtils {
   static bool PopulateHeaderBlockFromUrl(const std::string url,
                                          spdy::SpdyHeaderBlock* headers);
 
-  // Parses the "datagram-flow-id" header, returns the flow ID on success, or
-  // returns absl::nullopt if the header was not present or failed to parse.
-  static absl::optional<QuicDatagramStreamId> ParseDatagramFlowIdHeader(
-      const spdy::SpdyHeaderBlock& headers);
-
-  // Adds the "datagram-flow-id" header.
-  static void AddDatagramFlowIdHeader(spdy::SpdyHeaderBlock* headers,
-                                      QuicDatagramStreamId flow_id);
-
   // Returns the advertised QUIC version from the specified alternative service
   // advertisement, or ParsedQuicVersion::Unsupported() if no supported version
   // is advertised.

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

@@ -34,14 +34,6 @@ static std::unique_ptr<QuicHeaderList> FromList(
   return headers;
 }
 
-static void ValidateDatagramFlowId(
-    const std::string& header_value,
-    absl::optional<QuicDatagramStreamId> expected_flow_id) {
-  SpdyHeaderBlock headers;
-  headers["datagram-flow-id"] = header_value;
-  ASSERT_EQ(SpdyUtils::ParseDatagramFlowIdHeader(headers), expected_flow_id);
-}
-
 }  // anonymous namespace
 
 using CopyAndValidateHeaders = QuicTest;
@@ -386,30 +378,6 @@ TEST_F(PopulateHeaderBlockFromUrl, Failure) {
       SpdyUtils::PopulateHeaderBlockFromUrl("www.google.com/", &headers));
 }
 
-using DatagramFlowIdTest = QuicTest;
-
-TEST_F(DatagramFlowIdTest, DatagramFlowId) {
-  // Test missing header.
-  SpdyHeaderBlock headers;
-  EXPECT_EQ(SpdyUtils::ParseDatagramFlowIdHeader(headers), absl::nullopt);
-  // Add header and verify it parses.
-  QuicDatagramStreamId flow_id = 123;
-  SpdyUtils::AddDatagramFlowIdHeader(&headers, flow_id);
-  EXPECT_EQ(SpdyUtils::ParseDatagramFlowIdHeader(headers), flow_id);
-  // Test empty header.
-  ValidateDatagramFlowId("", absl::nullopt);
-  // Test invalid header.
-  ValidateDatagramFlowId("M4SQU3", absl::nullopt);
-  // Test simple header.
-  ValidateDatagramFlowId("42", 42);
-  // Test with parameter.
-  ValidateDatagramFlowId("42; abc=def", 42);
-  // Test list.
-  ValidateDatagramFlowId("42, 44; ecn-ect0, 46; ecn-ect1, 48; ecn-ce", 42);
-  // Test reordered list.
-  ValidateDatagramFlowId("44; ecn-ect0, 42, 48; ecn-ce, 46; ecn-ect1", 42);
-}
-
 using ExtractQuicVersionFromAltSvcEntry = QuicTest;
 
 TEST_F(ExtractQuicVersionFromAltSvcEntry, SupportedVersion) {

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

@@ -179,7 +179,6 @@ void WebTransportHttp3::HeadersReceived(const spdy::SpdyHeaderBlock& headers) {
       return;
     }
     bool should_validate_version =
-        session_->http_datagram_support() != HttpDatagramSupport::kDraft00 &&
         session_->ShouldValidateWebTransportVersion();
     if (should_validate_version) {
       auto draft_version_it = headers.find("sec-webtransport-http3-draft");

package/third_party/quiche/quiche/quic/core/packet_number_indexed_queue_test.cc

@@ -11,7 +11,7 @@
 #include "quiche/quic/core/quic_packet_number.h"
 #include "quiche/quic/platform/api/quic_test.h"
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 class PacketNumberIndexedQueueTest : public QuicTest {
@@ -202,4 +202,4 @@ TEST_F(PacketNumberIndexedQueueTest, ConstGetter) {
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

package/third_party/quiche/quiche/quic/core/qpack/qpack_header_table.cc

@@ -7,6 +7,7 @@
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/qpack/qpack_static_table.h"
 #include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/platform/api/quiche_logging.h"
 
 namespace quic {
 
@@ -232,7 +233,7 @@ void QpackDecoderHeaderTable::UnregisterObserver(uint64_t required_insert_count,
   }
 
   // |observer| must have been registered.
-  QUIC_NOTREACHED();
+  QUICHE_NOTREACHED();
 }
 
 }  // namespace quic

package/third_party/quiche/quiche/quic/core/qpack/qpack_send_stream.h

@@ -11,6 +11,7 @@
 #include "quiche/quic/core/qpack/qpack_stream_sender_delegate.h"
 #include "quiche/quic/core/quic_stream.h"
 #include "quiche/quic/platform/api/quic_export.h"
+#include "quiche/common/platform/api/quiche_logging.h"
 
 namespace quic {
 
@@ -36,7 +37,7 @@ class QUIC_EXPORT_PRIVATE QpackSendStream : public QuicStream,
 
   // The send QPACK stream is write unidirectional, so this method
   // should never be called.
-  void OnDataAvailable() override { QUIC_NOTREACHED(); }
+  void OnDataAvailable() override { QUICHE_NOTREACHED(); }
 
   // Writes the instructions to peer. The stream type will be sent
   // before the first instruction so that the peer can open an qpack stream.

package/third_party/quiche/quiche/quic/core/quic_arena_scoped_ptr_test.cc

@@ -7,7 +7,7 @@
 #include "quiche/quic/core/quic_one_block_arena.h"
 #include "quiche/quic/platform/api/quic_test.h"
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 enum class TestParam { kFromHeap, kFromArena };
@@ -112,4 +112,4 @@ TEST_P(QuicArenaScopedPtrParamTest, Swap) {
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test