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

package/third_party/quiche/quiche/quic/core/frames/quic_blocked_frame.cc

@@ -10,13 +10,6 @@ namespace quic {
 
 QuicBlockedFrame::QuicBlockedFrame() : QuicInlinedFrame(BLOCKED_FRAME) {}
 
-QuicBlockedFrame::QuicBlockedFrame(QuicControlFrameId control_frame_id,
-                                   QuicStreamId stream_id)
-    : QuicInlinedFrame(BLOCKED_FRAME),
-      control_frame_id(control_frame_id),
-      stream_id(stream_id),
-      offset(0) {}
-
 QuicBlockedFrame::QuicBlockedFrame(QuicControlFrameId control_frame_id,
                                    QuicStreamId stream_id,
                                    QuicStreamOffset offset)
@@ -28,7 +21,8 @@ QuicBlockedFrame::QuicBlockedFrame(QuicControlFrameId control_frame_id,
 std::ostream& operator<<(std::ostream& os,
                          const QuicBlockedFrame& blocked_frame) {
   os << "{ control_frame_id: " << blocked_frame.control_frame_id
-     << ", stream_id: " << blocked_frame.stream_id << " }\n";
+     << ", stream_id: " << blocked_frame.stream_id
+     << ", offset: " << blocked_frame.offset << " }\n";
   return os;
 }
 

package/third_party/quiche/quiche/quic/core/frames/quic_blocked_frame.h

@@ -20,7 +20,6 @@ namespace quic {
 struct QUIC_EXPORT_PRIVATE QuicBlockedFrame
     : public QuicInlinedFrame<QuicBlockedFrame> {
   QuicBlockedFrame();
-  QuicBlockedFrame(QuicControlFrameId control_frame_id, QuicStreamId stream_id);
   QuicBlockedFrame(QuicControlFrameId control_frame_id, QuicStreamId stream_id,
                    QuicStreamOffset offset);
 

package/third_party/quiche/quiche/quic/core/frames/quic_crypto_frame.h

@@ -25,6 +25,8 @@ struct QUIC_EXPORT_PRIVATE QuicCryptoFrame {
   friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                                       const QuicCryptoFrame& s);
 
+  // TODO(haoyuewang) Consider replace the EncryptionLevel here with
+  // PacketNumberSpace.
   // When writing a crypto frame to a packet, the packet must be encrypted at
   // |level|. When a crypto frame is read, the encryption level of the packet it
   // was received in is put in |level|.

package/third_party/quiche/quiche/quic/core/frames/quic_frames_test.cc

@@ -252,9 +252,10 @@ TEST_F(QuicFramesTest, BlockedFrameToString) {
   SetControlFrameId(4, &frame);
   EXPECT_EQ(4u, GetControlFrameId(frame));
   frame.blocked_frame.stream_id = 1;
+  frame.blocked_frame.offset = 2;
   std::ostringstream stream;
   stream << frame.blocked_frame;
-  EXPECT_EQ("{ control_frame_id: 4, stream_id: 1 }\n", stream.str());
+  EXPECT_EQ("{ control_frame_id: 4, stream_id: 1, offset: 2 }\n", stream.str());
   EXPECT_TRUE(IsControlFrame(frame.type));
 }
 

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

@@ -68,10 +68,8 @@ Capsule::Capsule(CapsuleType capsule_type) : capsule_type_(capsule_type) {
 
 // static
 Capsule Capsule::LegacyDatagram(
-    absl::optional<QuicDatagramContextId> context_id,
     absl::string_view http_datagram_payload) {
   Capsule capsule(CapsuleType::LEGACY_DATAGRAM);
-  capsule.legacy_datagram_capsule().context_id = context_id;
   capsule.legacy_datagram_capsule().http_datagram_payload =
       http_datagram_payload;
   return capsule;
@@ -134,10 +132,8 @@ bool Capsule::operator==(const Capsule& other) const {
   }
   switch (capsule_type_) {
     case CapsuleType::LEGACY_DATAGRAM:
-      return legacy_datagram_capsule_.context_id ==
-                 other.legacy_datagram_capsule_.context_id &&
-             legacy_datagram_capsule_.http_datagram_payload ==
-                 other.legacy_datagram_capsule_.http_datagram_payload;
+      return legacy_datagram_capsule_.http_datagram_payload ==
+             other.legacy_datagram_capsule_.http_datagram_payload;
     case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
       return datagram_without_context_capsule_.http_datagram_payload ==
              other.datagram_without_context_capsule_.http_datagram_payload;
@@ -155,10 +151,6 @@ std::string Capsule::ToString() const {
   std::string rv = CapsuleTypeToString(capsule_type_);
   switch (capsule_type_) {
     case CapsuleType::LEGACY_DATAGRAM:
-      if (legacy_datagram_capsule_.context_id.has_value()) {
-        absl::StrAppend(&rv, "(", legacy_datagram_capsule_.context_id.value(),
-                        ")");
-      }
       absl::StrAppend(&rv, "[",
                       absl::BytesToHexString(
                           legacy_datagram_capsule_.http_datagram_payload),
@@ -203,10 +195,6 @@ quiche::QuicheBuffer SerializeCapsule(
     case CapsuleType::LEGACY_DATAGRAM:
       capsule_data_length =
           capsule.legacy_datagram_capsule().http_datagram_payload.length();
-      if (capsule.legacy_datagram_capsule().context_id.has_value()) {
-        capsule_data_length += QuicDataWriter::GetVarInt62Len(
-            capsule.legacy_datagram_capsule().context_id.value());
-      }
       break;
     case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
       capsule_data_length = capsule.datagram_without_context_capsule()
@@ -237,14 +225,6 @@ quiche::QuicheBuffer SerializeCapsule(
   }
   switch (capsule.capsule_type()) {
     case CapsuleType::LEGACY_DATAGRAM:
-      if (capsule.legacy_datagram_capsule().context_id.has_value()) {
-        if (!writer.WriteVarInt62(
-                capsule.legacy_datagram_capsule().context_id.value())) {
-          QUIC_BUG(datagram capsule context ID write fail)
-              << "Failed to write LEGACY_DATAGRAM CAPSULE context ID";
-          return {};
-        }
-      }
       if (!writer.WriteStringPiece(
               capsule.legacy_datagram_capsule().http_datagram_payload)) {
         QUIC_BUG(datagram capsule payload write fail)

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

@@ -31,7 +31,6 @@ QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                              const CapsuleType& capsule_type);
 
 struct QUIC_EXPORT_PRIVATE LegacyDatagramCapsule {
-  absl::optional<QuicDatagramContextId> context_id;
   absl::string_view http_datagram_payload;
 };
 struct QUIC_EXPORT_PRIVATE DatagramWithoutContextCapsule {
@@ -50,7 +49,6 @@ struct QUIC_EXPORT_PRIVATE CloseWebTransportSessionCapsule {
 class QUIC_EXPORT_PRIVATE Capsule {
  public:
   static Capsule LegacyDatagram(
-      absl::optional<QuicDatagramContextId> context_id = absl::nullopt,
       absl::string_view http_datagram_payload = absl::string_view());
   static Capsule DatagramWithoutContext(
       absl::string_view http_datagram_payload = absl::string_view());

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

@@ -74,8 +74,7 @@ TEST_F(CapsuleTest, LegacyDatagramCapsule) {
       "a1a2a3a4a5a6a7a8"  // HTTP Datagram payload
   );
   std::string datagram_payload = absl::HexStringToBytes("a1a2a3a4a5a6a7a8");
-  Capsule expected_capsule =
-      Capsule::LegacyDatagram(/*context_id=*/absl::nullopt, datagram_payload);
+  Capsule expected_capsule = Capsule::LegacyDatagram(datagram_payload);
   {
     EXPECT_CALL(visitor_, OnCapsule(expected_capsule));
     ASSERT_TRUE(capsule_parser_.IngestCapsuleFragment(capsule_fragment));

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

@@ -17,10 +17,12 @@
 #include "absl/time/time.h"
 #include "quiche/quic/core/crypto/null_encrypter.h"
 #include "quiche/quic/core/crypto/quic_client_session_cache.h"
+#include "quiche/quic/core/frames/quic_blocked_frame.h"
 #include "quiche/quic/core/http/http_constants.h"
 #include "quiche/quic/core/http/quic_spdy_client_stream.h"
 #include "quiche/quic/core/http/web_transport_http3.h"
 #include "quiche/quic/core/quic_connection.h"
+#include "quiche/quic/core/quic_constants.h"
 #include "quiche/quic/core/quic_data_writer.h"
 #include "quiche/quic/core/quic_epoll_connection_helper.h"
 #include "quiche/quic/core/quic_error_codes.h"
@@ -91,27 +93,39 @@ const char kFooResponseBody[] = "Artichoke hearts make me happy.";
 const char kBarResponseBody[] = "Palm hearts are pretty delicious, also.";
 const char kTestUserAgentId[] = "quic/core/http/end_to_end_test.cc";
 const float kSessionToStreamRatio = 1.5;
+const int kLongConnectionIdLength = 16;
 
 // Run all tests with the cross products of all versions.
 struct TestParams {
-  TestParams(const ParsedQuicVersion& version, QuicTag congestion_control_tag)
-      : version(version), congestion_control_tag(congestion_control_tag) {}
+  TestParams(const ParsedQuicVersion& version, QuicTag congestion_control_tag,
+             int override_server_connection_id_length)
+      : version(version),
+        congestion_control_tag(congestion_control_tag),
+        override_server_connection_id_length(
+            override_server_connection_id_length) {}
 
   friend std::ostream& operator<<(std::ostream& os, const TestParams& p) {
     os << "{ version: " << ParsedQuicVersionToString(p.version);
     os << " congestion_control_tag: "
-       << QuicTagToString(p.congestion_control_tag) << " }";
+       << QuicTagToString(p.congestion_control_tag)
+       << " connection ID length: " << p.override_server_connection_id_length
+       << " }";
     return os;
   }
 
   ParsedQuicVersion version;
   QuicTag congestion_control_tag;
+  int override_server_connection_id_length;
 };
 
 // Used by ::testing::PrintToStringParamName().
 std::string PrintToString(const TestParams& p) {
-  std::string rv = absl::StrCat(ParsedQuicVersionToString(p.version), "_",
-                                QuicTagToString(p.congestion_control_tag));
+  std::string rv = absl::StrCat(
+      ParsedQuicVersionToString(p.version), "_",
+      QuicTagToString(p.congestion_control_tag), "_",
+      std::to_string((p.override_server_connection_id_length == -1)
+                         ? static_cast<int>(kQuicDefaultConnectionIdLength)
+                         : p.override_server_connection_id_length));
   std::replace(rv.begin(), rv.end(), ',', '_');
   std::replace(rv.begin(), rv.end(), ' ', '_');
   return rv;
@@ -120,15 +134,27 @@ std::string PrintToString(const TestParams& p) {
 // Constructs various test permutations.
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
-  for (const QuicTag congestion_control_tag : {kRENO, kTBBR, kQBIC, kB2ON}) {
-    if (!GetQuicReloadableFlag(quic_allow_client_enabled_bbr_v2) &&
-        congestion_control_tag == kB2ON) {
-      continue;
-    }
-    for (const ParsedQuicVersion& version : CurrentSupportedVersions()) {
-      params.push_back(TestParams(version, congestion_control_tag));
-    }  // End of outer version loop.
-  }    // End of congestion_control_tag loop.
+  std::vector<int> connection_id_lengths{-1, kLongConnectionIdLength};
+  for (auto connection_id_length : connection_id_lengths) {
+    for (const QuicTag congestion_control_tag : {kTBBR, kQBIC, kB2ON}) {
+      if (!GetQuicReloadableFlag(quic_allow_client_enabled_bbr_v2) &&
+          congestion_control_tag == kB2ON) {
+        continue;
+      }
+      for (const ParsedQuicVersion& version : CurrentSupportedVersions()) {
+        // TODO(b/232269029): Q050 should be able to handle 0-RTT when the
+        // initial connection ID is > 8 bytes, but it cannot. This is an
+        // invasive fix that has no impact as long as gQUIC clients always use
+        // 8B server connection IDs. If this bug is fixed, we can change
+        // 'UsesTls' to 'AllowsVariableLengthConnectionIds()' below to test
+        // qQUIC as well.
+        if (connection_id_length == -1 || version.UsesTls()) {
+          params.push_back(TestParams(version, congestion_control_tag,
+                                      connection_id_length));
+        }
+      }  // End of outer version loop.
+    }    // End of congestion_control_tag loop.
+  }      // End of connection_id_length loop.
 
   return params;
 }
@@ -182,6 +208,8 @@ class EndToEndTest : public QuicTestWithParam<TestParams> {
         server_supported_versions_(CurrentSupportedVersions()),
         chlo_multiplier_(0),
         stream_factory_(nullptr),
+        override_server_connection_id_length_(
+            GetParam().override_server_connection_id_length),
         expected_server_connection_id_length_(kQuicDefaultConnectionIdLength) {
     QUIC_LOG(INFO) << "Using Configuration: " << GetParam();
 
@@ -796,7 +824,7 @@ class EndToEndTest : public QuicTestWithParam<TestParams> {
     }
   }
 
-  ScopedEnvironmentForThreads environment_;
+  quiche::test::ScopedEnvironmentForThreads environment_;
   bool initialized_;
   // If true, the Initialize() function will create |client_| and starts to
   // connect to the server.
@@ -820,7 +848,7 @@ class EndToEndTest : public QuicTestWithParam<TestParams> {
   QuicTestServer::StreamFactory* stream_factory_;
   std::string pre_shared_key_client_;
   std::string pre_shared_key_server_;
-  int override_server_connection_id_length_ = -1;
+  int override_server_connection_id_length_;
   int override_client_connection_id_length_ = -1;
   uint8_t expected_server_connection_id_length_;
   bool enable_web_transport_ = false;
@@ -1080,7 +1108,8 @@ TEST_P(EndToEndTest, ForcedVersionNegotiation) {
 }
 
 TEST_P(EndToEndTest, SimpleRequestResponseZeroConnectionID) {
-  if (!version_.AllowsVariableLengthConnectionIds()) {
+  if (!version_.AllowsVariableLengthConnectionIds() ||
+      override_server_connection_id_length_ > -1) {
     ASSERT_TRUE(Initialize());
     return;
   }
@@ -1098,7 +1127,8 @@ TEST_P(EndToEndTest, SimpleRequestResponseZeroConnectionID) {
 }
 
 TEST_P(EndToEndTest, ZeroConnectionID) {
-  if (!version_.AllowsVariableLengthConnectionIds()) {
+  if (!version_.AllowsVariableLengthConnectionIds() ||
+      override_server_connection_id_length_ > -1) {
     ASSERT_TRUE(Initialize());
     return;
   }
@@ -1114,7 +1144,8 @@ TEST_P(EndToEndTest, ZeroConnectionID) {
 }
 
 TEST_P(EndToEndTest, BadConnectionIdLength) {
-  if (!version_.AllowsVariableLengthConnectionIds()) {
+  if (!version_.AllowsVariableLengthConnectionIds() ||
+      override_server_connection_id_length_ > -1) {
     ASSERT_TRUE(Initialize());
     return;
   }
@@ -1128,23 +1159,6 @@ TEST_P(EndToEndTest, BadConnectionIdLength) {
                                                 .length());
 }
 
-// Tests a very long (16-byte) initial destination connection ID to make
-// sure the dispatcher properly replaces it with an 8-byte one.
-TEST_P(EndToEndTest, LongBadConnectionIdLength) {
-  if (!version_.AllowsVariableLengthConnectionIds()) {
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  override_server_connection_id_length_ = 16;
-  ASSERT_TRUE(Initialize());
-  SendSynchronousFooRequestAndCheckResponse();
-  EXPECT_EQ(kQuicDefaultConnectionIdLength, client_->client()
-                                                ->client_session()
-                                                ->connection()
-                                                ->connection_id()
-                                                .length());
-}
-
 TEST_P(EndToEndTest, ClientConnectionId) {
   if (!version_.SupportsClientConnectionIds()) {
     ASSERT_TRUE(Initialize());
@@ -1179,7 +1193,8 @@ TEST_P(EndToEndTest, ForcedVersionNegotiationAndClientConnectionId) {
 }
 
 TEST_P(EndToEndTest, ForcedVersionNegotiationAndBadConnectionIdLength) {
-  if (!version_.AllowsVariableLengthConnectionIds()) {
+  if (!version_.AllowsVariableLengthConnectionIds() ||
+      override_server_connection_id_length_ > -1) {
     ASSERT_TRUE(Initialize());
     return;
   }
@@ -1200,13 +1215,13 @@ TEST_P(EndToEndTest, ForcedVersionNegotiationAndBadConnectionIdLength) {
 // connection ID.
 TEST_P(EndToEndTest, ForcedVersNegoAndClientCIDAndLongCID) {
   if (!version_.SupportsClientConnectionIds() ||
-      !version_.AllowsVariableLengthConnectionIds()) {
+      !version_.AllowsVariableLengthConnectionIds() ||
+      override_server_connection_id_length_ != kLongConnectionIdLength) {
     ASSERT_TRUE(Initialize());
     return;
   }
   client_supported_versions_.insert(client_supported_versions_.begin(),
                                     QuicVersionReservedForNegotiation());
-  override_server_connection_id_length_ = 16;
   override_client_connection_id_length_ = 18;
   ASSERT_TRUE(Initialize());
   ASSERT_TRUE(ServerSendsVersionNegotiation());
@@ -1224,7 +1239,8 @@ TEST_P(EndToEndTest, ForcedVersNegoAndClientCIDAndLongCID) {
 }
 
 TEST_P(EndToEndTest, MixGoodAndBadConnectionIdLengths) {
-  if (!version_.AllowsVariableLengthConnectionIds()) {
+  if (!version_.AllowsVariableLengthConnectionIds() ||
+      override_server_connection_id_length_ > -1) {
     ASSERT_TRUE(Initialize());
     return;
   }
@@ -1372,7 +1388,8 @@ TEST_P(EndToEndTest, MultipleRequestResponse) {
 }
 
 TEST_P(EndToEndTest, MultipleRequestResponseZeroConnectionID) {
-  if (!version_.AllowsVariableLengthConnectionIds()) {
+  if (!version_.AllowsVariableLengthConnectionIds() ||
+      override_server_connection_id_length_ > -1) {
     ASSERT_TRUE(Initialize());
     return;
   }
@@ -1531,7 +1548,14 @@ TEST_P(EndToEndTest, LargePostWithPacketLoss) {
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
-  VerifyCleanConnection(true);
+  if (override_server_connection_id_length_ == -1) {
+    // If the client sends a longer connection ID, we can end up with dropped
+    // packets. The packets_dropped counter increments whenever a packet arrives
+    // with a new server connection ID that is not INITIAL, RETRY, or 1-RTT.
+    // With packet losses, we could easily lose a server INITIAL and have the
+    // first observed server packet be HANDSHAKE.
+    VerifyCleanConnection(true);
+  }
 }
 
 // Regression test for b/80090281.
@@ -4454,6 +4478,72 @@ class ServerStreamThatSendsHugeResponseFactory
   int64_t body_bytes_;
 };
 
+class BlockedFrameObserver : public QuicConnectionDebugVisitor {
+ public:
+  std::vector<QuicBlockedFrame> blocked_frames() const {
+    return blocked_frames_;
+  }
+
+  void OnBlockedFrame(const QuicBlockedFrame& frame) override {
+    blocked_frames_.push_back(frame);
+  }
+
+ private:
+  std::vector<QuicBlockedFrame> blocked_frames_;
+};
+
+TEST_P(EndToEndTest, BlockedFrameIncludesOffset) {
+  if (!version_.HasIetfQuicFrames()) {
+    // For Google QUIC, the BLOCKED frame offset is ignored.
+    Initialize();
+    return;
+  }
+
+  set_smaller_flow_control_receive_window();
+  ASSERT_TRUE(Initialize());
+
+  // Observe the connection for BLOCKED frames.
+  BlockedFrameObserver observer;
+  QuicConnection* client_connection = GetClientConnection();
+  ASSERT_TRUE(client_connection);
+  client_connection->set_debug_visitor(&observer);
+
+  // Set the response body larger than the flow control window so the server
+  // must receive a window update from the client before it can finish sending
+  // it (hence, causing the server to send a BLOCKED frame)
+  uint32_t response_body_size =
+      client_config_.GetInitialSessionFlowControlWindowToSend() + 10;
+  std::string response_body(response_body_size, 'a');
+  AddToCache("/blocked", 200, response_body);
+  SendSynchronousRequestAndCheckResponse("/blocked", response_body);
+  client_->Disconnect();
+
+  bool include_offset_flag =
+      GetQuicReloadableFlag(quic_include_offset_in_blocked_frames);
+  QuicStreamOffset expected_connection_offset =
+      include_offset_flag
+          ? client_config_.GetInitialSessionFlowControlWindowToSend()
+          : 0;
+  QuicStreamOffset expected_stream_offset =
+      include_offset_flag
+          ? client_config_.GetInitialStreamFlowControlWindowToSend()
+          : 0;
+
+  ASSERT_GE(observer.blocked_frames().size(), static_cast<uint64_t>(0));
+  for (const QuicBlockedFrame& frame : observer.blocked_frames()) {
+    if (frame.stream_id ==
+        QuicUtils::GetInvalidStreamId(version_.transport_version)) {
+      // connection-level BLOCKED frame
+      ASSERT_EQ(frame.offset, expected_connection_offset);
+    } else {
+      // stream-level BLOCKED frame
+      ASSERT_EQ(frame.offset, expected_stream_offset);
+    }
+  }
+
+  client_connection->set_debug_visitor(nullptr);
+}
+
 TEST_P(EndToEndTest, EarlyResponseFinRecording) {
   set_smaller_flow_control_receive_window();
 
@@ -4774,6 +4864,8 @@ TEST_P(EndToEndTest, SendStatelessResetTokenInShlo) {
 // Regression test for b/116200989.
 TEST_P(EndToEndTest,
        SendStatelessResetIfServerConnectionClosedLocallyDuringHandshake) {
+  SetQuicReloadableFlag(
+      quic_consider_original_connection_id_as_active_pre_handshake, true);
   connect_to_server_on_initialize_ = false;
   ASSERT_TRUE(Initialize());
 
@@ -5562,14 +5654,12 @@ TEST_P(EndToEndPacketReorderingTest, Buffer0RttRequest) {
   // Disconnect for next 0-rtt request.
   client_->Disconnect();
 
-  // Client get valid STK now. Do a 0-rtt request.
-  // Buffer a CHLO till another packets sent out.
-  reorder_writer_->SetDelay(1);
+  // Client has valid Session Ticket now. Do a 0-RTT request.
+  // Buffer a CHLO till the request is sent out. HTTP/3 sends two packets: a
+  // SETTINGS frame and a request.
+  reorder_writer_->SetDelay(version_.UsesHttp3() ? 2 : 1);
   // Only send out a CHLO.
   client_->client()->Initialize();
-  client_->client()->StartConnect();
-  EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
-  ASSERT_TRUE(client_->client()->connected());
 
   // Send a request before handshake finishes.
   SpdyHeaderBlock headers;
@@ -5584,10 +5674,7 @@ TEST_P(EndToEndPacketReorderingTest, Buffer0RttRequest) {
   QuicConnection* client_connection = GetClientConnection();
   ASSERT_TRUE(client_connection);
   QuicConnectionStats client_stats = client_connection->GetStats();
-  // Client sends CHLO in packet 1 and retransmitted in packet 2. Because of
-  // the delay, server processes packet 2 and later drops packet 1. ACK is
-  // bundled with SHLO, such that 1 can be detected loss by time threshold.
-  EXPECT_LE(0u, client_stats.packets_lost);
+  EXPECT_EQ(0u, client_stats.packets_lost);
   EXPECT_TRUE(client_->client()->EarlyDataAccepted());
 }
 
@@ -5853,7 +5940,8 @@ TEST_P(EndToEndTest, CustomTransportParameters) {
 }
 
 TEST_P(EndToEndTest, LegacyVersionEncapsulation) {
-  if (!version_.HasLongHeaderLengths()) {
+  if (!version_.HasLongHeaderLengths() ||
+      override_server_connection_id_length_ > -1) {
     // Decapsulating Legacy Version Encapsulation packets from these versions
     // is not currently supported in QuicDispatcher.
     ASSERT_TRUE(Initialize());
@@ -5870,7 +5958,8 @@ TEST_P(EndToEndTest, LegacyVersionEncapsulation) {
 }
 
 TEST_P(EndToEndTest, LegacyVersionEncapsulationWithMultiPacketChlo) {
-  if (!version_.HasLongHeaderLengths()) {
+  if (!version_.HasLongHeaderLengths() ||
+      override_server_connection_id_length_ > -1) {
     // Decapsulating Legacy Version Encapsulation packets from these versions
     // is not currently supported in QuicDispatcher.
     ASSERT_TRUE(Initialize());
@@ -5897,7 +5986,8 @@ TEST_P(EndToEndTest, LegacyVersionEncapsulationWithMultiPacketChlo) {
 }
 
 TEST_P(EndToEndTest, LegacyVersionEncapsulationWithVersionNegotiation) {
-  if (!version_.HasLongHeaderLengths()) {
+  if (!version_.HasLongHeaderLengths() ||
+      override_server_connection_id_length_ > -1) {
     // Decapsulating Legacy Version Encapsulation packets from these versions
     // is not currently supported in QuicDispatcher.
     ASSERT_TRUE(Initialize());
@@ -5916,7 +6006,8 @@ TEST_P(EndToEndTest, LegacyVersionEncapsulationWithVersionNegotiation) {
 }
 
 TEST_P(EndToEndTest, LegacyVersionEncapsulationWithLoss) {
-  if (!version_.HasLongHeaderLengths()) {
+  if (!version_.HasLongHeaderLengths() ||
+      override_server_connection_id_length_ > -1) {
     // Decapsulating Legacy Version Encapsulation packets from these versions
     // is not currently supported in QuicDispatcher.
     ASSERT_TRUE(Initialize());
@@ -5979,7 +6070,7 @@ TEST_P(EndToEndTest, ChaosProtectionDisabled) {
   // Parse the saved packet to make sure it's valid.
   SimpleQuicFramer validation_framer({version_});
   validation_framer.framer()->SetInitialObfuscators(
-      GetClientConnection()->connection_id());
+      GetClientConnection()->GetOriginalDestinationConnectionId());
   ASSERT_GT(copying_writer->packets().size(), 0u);
   EXPECT_TRUE(validation_framer.ProcessPacket(*copying_writer->packets()[0]));
   // TODO(dschinazi) figure out a way to use a MockRandom in this test so we

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

@@ -17,8 +17,8 @@ std::string H3SettingsToString(Http3AndQpackSettingsIdentifiers identifier) {
     RETURN_STRING_LITERAL(SETTINGS_QPACK_MAX_TABLE_CAPACITY);
     RETURN_STRING_LITERAL(SETTINGS_MAX_FIELD_SECTION_SIZE);
     RETURN_STRING_LITERAL(SETTINGS_QPACK_BLOCKED_STREAMS);
-    RETURN_STRING_LITERAL(SETTINGS_H3_DATAGRAM_DRAFT00);
     RETURN_STRING_LITERAL(SETTINGS_H3_DATAGRAM_DRAFT04);
+    RETURN_STRING_LITERAL(SETTINGS_H3_DATAGRAM_DRAFT09);
     RETURN_STRING_LITERAL(SETTINGS_WEBTRANS_DRAFT00);
     RETURN_STRING_LITERAL(SETTINGS_ENABLE_CONNECT_PROTOCOL);
   }

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

@@ -38,10 +38,10 @@ enum Http3AndQpackSettingsIdentifiers : uint64_t {
   // Same value as spdy::SETTINGS_MAX_HEADER_LIST_SIZE.
   SETTINGS_MAX_FIELD_SECTION_SIZE = 0x06,
   SETTINGS_QPACK_BLOCKED_STREAMS = 0x07,
-  // draft-ietf-masque-h3-datagram-00.
-  SETTINGS_H3_DATAGRAM_DRAFT00 = 0x276,
   // draft-ietf-masque-h3-datagram-04.
   SETTINGS_H3_DATAGRAM_DRAFT04 = 0xffd277,
+  // draft-ietf-masque-h3-datagram-09.
+  SETTINGS_H3_DATAGRAM_DRAFT09 = 0x33,
   // draft-ietf-webtrans-http3-00
   SETTINGS_WEBTRANS_DRAFT00 = 0x2b603742,
   // draft-ietf-httpbis-h3-websockets

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

@@ -12,7 +12,7 @@
 using ::testing::ElementsAre;
 using ::testing::Pair;
 
-namespace quic {
+namespace quic::test {
 
 class QuicHeaderListTest : public QuicTest {};
 
@@ -83,4 +83,4 @@ TEST_F(QuicHeaderListTest, IsCopyableAndAssignable) {
                                     Pair("beep", "")));
 }
 
-}  // namespace quic
+}  // namespace quic::test

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

@@ -101,9 +101,9 @@ class MockVisitor : public SpdyFramerVisitorInterface {
               (SpdyStreamId last_accepted_stream_id, SpdyErrorCode error_code),
               (override));
   MOCK_METHOD(void, OnHeaders,
-              (SpdyStreamId stream_id, bool has_priority, int weight,
-               SpdyStreamId parent_stream_id, bool exclusive, bool fin,
-               bool end),
+              (SpdyStreamId stream_id, size_t payload_length, bool has_priority,
+               int weight, SpdyStreamId parent_stream_id, bool exclusive,
+               bool fin, bool end),
               (override));
   MOCK_METHOD(void, OnWindowUpdate,
               (SpdyStreamId stream_id, int delta_window_size), (override));
@@ -111,7 +111,8 @@ class MockVisitor : public SpdyFramerVisitorInterface {
               (SpdyStreamId stream_id, SpdyStreamId promised_stream_id,
                bool end),
               (override));
-  MOCK_METHOD(void, OnContinuation, (SpdyStreamId stream_id, bool end),
+  MOCK_METHOD(void, OnContinuation,
+              (SpdyStreamId stream_id, size_t payload_size, bool end),
               (override));
   MOCK_METHOD(
       void, OnAltSvc,
@@ -281,17 +282,20 @@ class QuicHeadersStreamTest : public QuicTestWithParam<TestParams> {
 
     // Parse the outgoing data and check that it matches was was written.
     if (is_request) {
-      EXPECT_CALL(visitor_,
-                  OnHeaders(stream_id, kHasPriority,
-                            Spdy3PriorityToHttp2Weight(priority),
-                            /*parent_stream_id=*/0,
-                            /*exclusive=*/false, fin, kFrameComplete));
+      EXPECT_CALL(
+          visitor_,
+          OnHeaders(stream_id, saved_data_.length() - spdy::kFrameHeaderSize,
+                    kHasPriority, Spdy3PriorityToHttp2Weight(priority),
+                    /*parent_stream_id=*/0,
+                    /*exclusive=*/false, fin, kFrameComplete));
     } else {
-      EXPECT_CALL(visitor_,
-                  OnHeaders(stream_id, !kHasPriority,
-                            /*weight=*/0,
-                            /*parent_stream_id=*/0,
-                            /*exclusive=*/false, fin, kFrameComplete));
+      EXPECT_CALL(
+          visitor_,
+          OnHeaders(stream_id, saved_data_.length() - spdy::kFrameHeaderSize,
+                    !kHasPriority,
+                    /*weight=*/0,
+                    /*parent_stream_id=*/0,
+                    /*exclusive=*/false, fin, kFrameComplete));
     }
     headers_handler_ = std::make_unique<RecordingHeadersHandler>();
     EXPECT_CALL(visitor_, OnHeaderFrameStart(stream_id))

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

@@ -10,6 +10,7 @@
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/platform/api/quiche_logging.h"
 
 namespace quic {
 
@@ -46,7 +47,7 @@ class QUIC_EXPORT_PRIVATE QuicSendControlStream : public QuicStream {
 
   // The send control stream is write unidirectional, so this method should
   // never be called.
-  void OnDataAvailable() override { QUIC_NOTREACHED(); }
+  void OnDataAvailable() override { QUICHE_NOTREACHED(); }
 
  private:
   // Track if a settings frame is already sent.