@fails-components/webtransport 0.0.1-rc.2 → 0.0.1

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

@@ -5883,6 +5883,35 @@ TEST(NgHttp2AdapterTest, AutomaticPingAcksDisabled) {
   EXPECT_THAT(visitor.data(), EqualsFrames({SpdyFrameType::SETTINGS}));
 }
 
+TEST(NgHttp2AdapterTest, InvalidMaxFrameSize) {
+  DataSavingVisitor visitor;
+  auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);
+
+  const std::string frames =
+      TestFrameSequence().ClientPreface({{MAX_FRAME_SIZE, 3}}).Serialize();
+  testing::InSequence s;
+
+  // Client preface
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(
+      visitor,
+      OnInvalidFrame(0, Http2VisitorInterface::InvalidFrameError::kProtocol));
+
+  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, ServerForbidsProtocolPseudoheaderBeforeAck) {
   DataSavingVisitor visitor;
   auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);
@@ -6793,6 +6822,96 @@ TEST(NgHttp2AdapterTest, ServerHandlesConnectionSpecificHeaders) {
                     SpdyFrameType::RST_STREAM, SpdyFrameType::RST_STREAM}));
 }
 
+TEST(NgHttp2AdapterTest, NegativeFlowControlStreamResumption) {
+  DataSavingVisitor visitor;
+  auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);
+
+  const std::string frames =
+      TestFrameSequence()
+          .ClientPreface({{INITIAL_WINDOW_SIZE, 128u * 1024u}})
+          .WindowUpdate(0, 1 << 20)
+          .Headers(1,
+                   {{":method", "GET"},
+                    {":scheme", "https"},
+                    {":authority", "example.com"},
+                    {":path", "/this/is/request/one"}},
+                   /*fin=*/true)
+          .Serialize();
+  testing::InSequence s;
+
+  // Client preface (empty SETTINGS)
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  EXPECT_CALL(visitor,
+              OnSetting(Http2Setting{Http2KnownSettingsId::INITIAL_WINDOW_SIZE,
+                                     128u * 1024u}));
+  EXPECT_CALL(visitor, OnSettingsEnd());
+
+  EXPECT_CALL(visitor, OnFrameHeader(0, 4, WINDOW_UPDATE, 0));
+  EXPECT_CALL(visitor, OnWindowUpdate(0, 1 << 20));
+
+  // Stream 1
+  EXPECT_CALL(visitor, OnFrameHeader(1, _, HEADERS, 0x5));
+  EXPECT_CALL(visitor, OnBeginHeadersForStream(1));
+  EXPECT_CALL(visitor, OnHeaderForStream(1, _, _)).Times(4);
+  EXPECT_CALL(visitor, OnEndHeadersForStream(1));
+  EXPECT_CALL(visitor, OnEndStream(1));
+
+  const int64_t read_result = adapter->ProcessBytes(frames);
+  EXPECT_EQ(static_cast<size_t>(read_result), frames.size());
+
+  // Submit a response for the stream.
+  auto body = absl::make_unique<TestDataFrameSource>(visitor, true);
+  TestDataFrameSource& body_ref = *body;
+  body_ref.AppendPayload(std::string(70000, 'a'));
+  int submit_result = adapter->SubmitResponse(
+      1, ToHeaders({{":status", "200"}}), std::move(body));
+  ASSERT_EQ(0, submit_result);
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+  EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+  EXPECT_CALL(visitor, OnBeforeFrameSent(HEADERS, 1, _, 0x4));
+  EXPECT_CALL(visitor, OnFrameSent(HEADERS, 1, _, 0x4, 0));
+  EXPECT_CALL(visitor, OnFrameSent(DATA, 1, _, 0x0, 0)).Times(5);
+
+  adapter->Send();
+  EXPECT_FALSE(adapter->want_write());
+
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  EXPECT_CALL(visitor,
+              OnSetting(Http2Setting{Http2KnownSettingsId::INITIAL_WINDOW_SIZE,
+                                     64u * 1024u}));
+  EXPECT_CALL(visitor, OnSettingsEnd());
+
+  // Processing these SETTINGS will cause stream 1's send window to become
+  // negative.
+  adapter->ProcessBytes(TestFrameSequence()
+                            .Settings({{INITIAL_WINDOW_SIZE, 64u * 1024u}})
+                            .Serialize());
+  EXPECT_TRUE(adapter->want_write());
+  // nghttp2 does not expose the fact that the send window size is negative.
+  EXPECT_EQ(adapter->GetStreamSendWindowSize(1), 0);
+
+  body_ref.AppendPayload("Stream should be resumed.");
+  adapter->ResumeStream(1);
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+  EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+  adapter->Send();
+  EXPECT_FALSE(adapter->want_write());
+
+  // Upon receiving the WINDOW_UPDATE, stream 1 should be ready to write.
+  EXPECT_CALL(visitor, OnFrameHeader(1, 4, WINDOW_UPDATE, 0));
+  EXPECT_CALL(visitor, OnWindowUpdate(1, 10000));
+  adapter->ProcessBytes(TestFrameSequence().WindowUpdate(1, 10000).Serialize());
+  EXPECT_TRUE(adapter->want_write());
+  EXPECT_GT(adapter->GetStreamSendWindowSize(1), 0);
+
+  EXPECT_CALL(visitor, OnFrameSent(DATA, 1, _, 0x0, 0));
+  adapter->Send();
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace adapter

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

@@ -347,6 +347,42 @@ TEST(OgHttp2AdapterTest, AutomaticPingAcksDisabled) {
               EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::SETTINGS}));
 }
 
+TEST(OgHttp2AdapterTest, InvalidMaxFrameSize) {
+  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();
+  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, ClientHandles100Headers) {
   DataSavingVisitor visitor;
   OgHttp2Adapter::Options options;
@@ -7556,6 +7592,100 @@ TEST(OgHttp2AdapterTest, NoopHeaderValidatorTest) {
   EXPECT_EQ(frames.size(), static_cast<size_t>(result));
 }
 
+TEST(OgHttp2AdapterTest, NegativeFlowControlStreamResumption) {
+  DataSavingVisitor visitor;
+  OgHttp2Adapter::Options options;
+  options.perspective = Perspective::kServer;
+  auto adapter = OgHttp2Adapter::Create(visitor, options);
+
+  const std::string frames =
+      TestFrameSequence()
+          .ClientPreface({{INITIAL_WINDOW_SIZE, 128u * 1024u}})
+          .WindowUpdate(0, 1 << 20)
+          .Headers(1,
+                   {{":method", "GET"},
+                    {":scheme", "https"},
+                    {":authority", "example.com"},
+                    {":path", "/this/is/request/one"}},
+                   /*fin=*/true)
+          .Serialize();
+  testing::InSequence s;
+
+  // Client preface (empty SETTINGS)
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  EXPECT_CALL(visitor,
+              OnSetting(Http2Setting{Http2KnownSettingsId::INITIAL_WINDOW_SIZE,
+                                     128u * 1024u}));
+  EXPECT_CALL(visitor, OnSettingsEnd());
+
+  EXPECT_CALL(visitor, OnFrameHeader(0, 4, WINDOW_UPDATE, 0));
+  EXPECT_CALL(visitor, OnWindowUpdate(0, 1 << 20));
+
+  // Stream 1
+  EXPECT_CALL(visitor, OnFrameHeader(1, _, HEADERS, 0x5));
+  EXPECT_CALL(visitor, OnBeginHeadersForStream(1));
+  EXPECT_CALL(visitor, OnHeaderForStream(1, _, _)).Times(4);
+  EXPECT_CALL(visitor, OnEndHeadersForStream(1));
+  EXPECT_CALL(visitor, OnEndStream(1));
+
+  const int64_t read_result = adapter->ProcessBytes(frames);
+  EXPECT_EQ(static_cast<size_t>(read_result), frames.size());
+
+  // Submit a response for the stream.
+  auto body = absl::make_unique<TestDataFrameSource>(visitor, true);
+  TestDataFrameSource& body_ref = *body;
+  body_ref.AppendPayload(std::string(70000, 'a'));
+  int submit_result = adapter->SubmitResponse(
+      1, ToHeaders({{":status", "200"}}), std::move(body));
+  ASSERT_EQ(0, submit_result);
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x0));
+  EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x0, 0));
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+  EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+  EXPECT_CALL(visitor, OnBeforeFrameSent(HEADERS, 1, _, 0x4));
+  EXPECT_CALL(visitor, OnFrameSent(HEADERS, 1, _, 0x4, 0));
+  EXPECT_CALL(visitor, OnFrameSent(DATA, 1, _, 0x0, 0)).Times(5);
+
+  adapter->Send();
+  EXPECT_FALSE(adapter->want_write());
+
+  EXPECT_CALL(visitor, OnFrameHeader(0, 6, SETTINGS, 0));
+  EXPECT_CALL(visitor, OnSettingsStart());
+  EXPECT_CALL(visitor,
+              OnSetting(Http2Setting{Http2KnownSettingsId::INITIAL_WINDOW_SIZE,
+                                     64u * 1024u}));
+  EXPECT_CALL(visitor, OnSettingsEnd());
+
+  // Processing these SETTINGS will cause stream 1's send window to become
+  // negative.
+  adapter->ProcessBytes(TestFrameSequence()
+                            .Settings({{INITIAL_WINDOW_SIZE, 64u * 1024u}})
+                            .Serialize());
+  EXPECT_TRUE(adapter->want_write());
+  EXPECT_LT(adapter->GetStreamSendWindowSize(1), 0);
+
+  body_ref.AppendPayload("Stream should be resumed.");
+  adapter->ResumeStream(1);
+
+  EXPECT_CALL(visitor, OnBeforeFrameSent(SETTINGS, 0, _, 0x1));
+  EXPECT_CALL(visitor, OnFrameSent(SETTINGS, 0, _, 0x1, 0));
+  adapter->Send();
+  EXPECT_FALSE(adapter->want_write());
+
+  // Upon receiving the WINDOW_UPDATE, stream 1 should be ready to write.
+  EXPECT_CALL(visitor, OnFrameHeader(1, 4, WINDOW_UPDATE, 0));
+  EXPECT_CALL(visitor, OnWindowUpdate(1, 10000));
+  adapter->ProcessBytes(TestFrameSequence().WindowUpdate(1, 10000).Serialize());
+  EXPECT_TRUE(adapter->want_write());
+  EXPECT_GT(adapter->GetStreamSendWindowSize(1), 0);
+
+  EXPECT_CALL(visitor, OnFrameSent(DATA, 1, _, 0x0, 0));
+  adapter->Send();
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace adapter

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

@@ -1218,16 +1218,6 @@ void OgHttp2Session::OnSettings() {
 
 void OgHttp2Session::OnSetting(spdy::SpdySettingsId id, uint32_t value) {
   switch (id) {
-    case MAX_FRAME_SIZE:
-      max_frame_payload_ = value;
-      break;
-    case MAX_CONCURRENT_STREAMS:
-      max_outbound_concurrent_streams_ = value;
-      if (!IsServerSession()) {
-        // We may now be able to start pending streams.
-        StartPendingStreams();
-      }
-      break;
     case HEADER_TABLE_SIZE:
       value = std::min(value, HpackCapacityBound(options_));
       if (value < framer_.GetHpackEncoder()->CurrentHeaderTableSizeSetting()) {
@@ -1243,6 +1233,13 @@ void OgHttp2Session::OnSetting(spdy::SpdySettingsId id, uint32_t value) {
         encoder_header_table_capacity_when_acking_ = value;
       }
       break;
+    case MAX_CONCURRENT_STREAMS:
+      max_outbound_concurrent_streams_ = value;
+      if (!IsServerSession()) {
+        // We may now be able to start pending streams.
+        StartPendingStreams();
+      }
+      break;
     case INITIAL_WINDOW_SIZE:
       if (value > spdy::kSpdyMaximumWindowSize) {
         visitor_.OnInvalidFrame(
@@ -1256,6 +1253,19 @@ void OgHttp2Session::OnSetting(spdy::SpdySettingsId id, uint32_t value) {
         UpdateStreamSendWindowSizes(value);
       }
       break;
+    case MAX_FRAME_SIZE:
+      if (value < kDefaultFramePayloadSizeLimit ||
+          value > kMaximumFramePayloadSizeLimit) {
+        visitor_.OnInvalidFrame(
+            0, Http2VisitorInterface::InvalidFrameError::kProtocol);
+        // The specification says this is a connection-level protocol error.
+        LatchErrorAndNotify(
+            Http2ErrorCode::PROTOCOL_ERROR,
+            Http2VisitorInterface::ConnectionError::kInvalidSetting);
+        return;
+      }
+      max_frame_payload_ = value;
+      break;
     default:
       // TODO(bnc): See if C++17 inline constants are allowed in QUICHE.
       if (id == kMetadataExtensionId) {
@@ -1416,12 +1426,13 @@ void OgHttp2Session::OnWindowUpdate(spdy::SpdyStreamId stream_id,
       if (streams_reset_.contains(stream_id)) {
         return;
       }
-      if (it->second.send_window == 0) {
+      const bool was_blocked = (it->second.send_window <= 0);
+      it->second.send_window += delta_window_size;
+      if (was_blocked && it->second.send_window > 0) {
         // The stream was blocked on flow control.
         QUICHE_VLOG(1) << "Marking stream " << stream_id << " ready to write.";
         write_scheduler_.MarkStreamReady(stream_id, false);
       }
-      it->second.send_window += delta_window_size;
     }
   }
   visitor_.OnWindowUpdate(stream_id, delta_window_size);

package/third_party/quiche/quiche/http2/decoder/decode_buffer_test.cc

@@ -131,14 +131,9 @@ TEST(DecodeBufferDeathTest, NonNullBufferRequired) {
 TEST(DecodeBufferDeathTest, ModestBufferSizeRequired) {
   EXPECT_QUICHE_DEBUG_DEATH(
       {
-        // This depends on being able to allocate a fairly large array on the
-        // stack. If that fails, we can instead do this:
-        //
-        //   std::string data(DecodeBuffer::kMaxDecodeBufferLength + 1, ' ');
-        //   DecodeBuffer b(data.data(), data.size());
-
-        const char data[DecodeBuffer::kMaxDecodeBufferLength + 1] = {};
-        DecodeBuffer b(data, sizeof data);
+        constexpr size_t kLength = DecodeBuffer::kMaxDecodeBufferLength + 1;
+        auto data = std::make_unique<char[]>(kLength);
+        DecodeBuffer b(data.get(), kLength);
       },
       "Max.*Length");
 }
@@ -159,7 +154,7 @@ TEST(DecodeBufferDeathTest, LimitedAdvance) {
         DecodeBuffer b(data, 3);
         b.AdvanceCursor(4);
       },
-      "4 vs. 3");
+      "Remaining");
 }
 
 // Make sure that DecodeBuffer detects decode beyond end, in debug mode.
@@ -168,7 +163,7 @@ TEST(DecodeBufferDeathTest, DecodeUInt8PastEnd) {
   DecodeBuffer b(data, sizeof data);
   EXPECT_EQ(2u, b.FullSize());
   EXPECT_EQ(0x1223, b.DecodeUInt16());
-  EXPECT_QUICHE_DEBUG_DEATH({ b.DecodeUInt8(); }, "1 vs. 0");
+  EXPECT_QUICHE_DEBUG_DEATH({ b.DecodeUInt8(); }, "Remaining");
 }
 
 // Make sure that DecodeBuffer detects decode beyond end, in debug mode.
@@ -177,7 +172,7 @@ TEST(DecodeBufferDeathTest, DecodeUInt16OverEnd) {
   DecodeBuffer b(data, sizeof data);
   EXPECT_EQ(3u, b.FullSize());
   EXPECT_EQ(0x1223, b.DecodeUInt16());
-  EXPECT_QUICHE_DEBUG_DEATH({ b.DecodeUInt16(); }, "2 vs. 1");
+  EXPECT_QUICHE_DEBUG_DEATH({ b.DecodeUInt16(); }, "Remaining");
 }
 
 // Make sure that DecodeBuffer doesn't agree with having two subsets.

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

@@ -505,11 +505,6 @@ void Bbr2Sender::OnExitQuiescence(QuicTime now) {
   }
 }
 
-bool Bbr2Sender::ShouldSendProbingPacket() const {
-  // TODO(wub): Implement ShouldSendProbingPacket properly.
-  return BBR2_MODE_DISPATCH(IsProbingForBandwidth());
-}
-
 std::string Bbr2Sender::GetDebugState() const {
   std::ostringstream stream;
   stream << ExportDebugState();

package/third_party/quiche/quiche/quic/core/congestion_control/bbr2_sender.h

@@ -42,8 +42,6 @@ class QUIC_EXPORT_PRIVATE Bbr2Sender final : public SendAlgorithmInterface {
     return false;
   }
 
-  bool ShouldSendProbingPacket() const override;
-
   void SetFromConfig(const QuicConfig& config,
                      Perspective perspective) override;
 

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

@@ -204,16 +204,6 @@ bool BbrSender::InRecovery() const {
   return recovery_state_ != NOT_IN_RECOVERY;
 }
 
-bool BbrSender::ShouldSendProbingPacket() const {
-  if (pacing_gain_ <= 1) {
-    return false;
-  }
-
-  // TODO(b/77975811): If the pipe is highly under-utilized, consider not
-  // sending a probing transmission, because the extra bandwidth is not needed.
-  return true;
-}
-
 void BbrSender::SetFromConfig(const QuicConfig& config,
                               Perspective perspective) {
   if (config.HasClientRequestedIndependentOption(k1RTT, perspective)) {

package/third_party/quiche/quiche/quic/core/congestion_control/bbr_sender.h

@@ -100,7 +100,6 @@ class QUIC_EXPORT_PRIVATE BbrSender : public SendAlgorithmInterface {
   // Start implementation of SendAlgorithmInterface.
   bool InSlowStart() const override;
   bool InRecovery() const override;
-  bool ShouldSendProbingPacket() const override;
 
   void SetFromConfig(const QuicConfig& config,
                      Perspective perspective) override;

package/third_party/quiche/quiche/quic/core/congestion_control/send_algorithm_interface.h

@@ -129,12 +129,6 @@ class QUIC_EXPORT_PRIVATE SendAlgorithmInterface {
   // Whether the send algorithm is currently in recovery.
   virtual bool InRecovery() const = 0;
 
-  // True when the congestion control is probing for more bandwidth and needs
-  // enough data to not be app-limited to do so.
-  // TODO(ianswett): In the future, this API may want to indicate the size of
-  // the probing packet.
-  virtual bool ShouldSendProbingPacket() const = 0;
-
   // Returns the size of the slow start congestion window in bytes,
   // aka ssthresh.  Only defined for Cubic and Reno, other algorithms return 0.
   virtual QuicByteCount GetSlowStartThreshold() const = 0;

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

@@ -233,8 +233,6 @@ bool TcpCubicSenderBytes::InRecovery() const {
          largest_acked_packet_number_ <= largest_sent_at_last_cutback_;
 }
 
-bool TcpCubicSenderBytes::ShouldSendProbingPacket() const { return false; }
-
 void TcpCubicSenderBytes::OnRetransmissionTimeout(bool packets_retransmitted) {
   largest_sent_at_last_cutback_.Clear();
   if (!packets_retransmitted) {

package/third_party/quiche/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h

@@ -69,7 +69,6 @@ class QUIC_EXPORT_PRIVATE TcpCubicSenderBytes : public SendAlgorithmInterface {
   CongestionControlType GetCongestionControlType() const override;
   bool InSlowStart() const override;
   bool InRecovery() const override;
-  bool ShouldSendProbingPacket() const override;
   std::string GetDebugState() const override;
   void OnApplicationLimited(QuicByteCount bytes_in_flight) override;
   void PopulateConnectionStats(QuicConnectionStats* /*stats*/) const override {}

package/third_party/quiche/quiche/quic/core/crypto/transport_parameters_test.cc

@@ -484,12 +484,10 @@ TEST_P(TransportParametersTest, NoClientParamsWithStatelessResetToken) {
   orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
 
   std::vector<uint8_t> out;
-  bool ok = true;
   EXPECT_QUIC_BUG(
-      ok = SerializeTransportParameters(orig_params, &out),
+      EXPECT_FALSE(SerializeTransportParameters(orig_params, &out)),
       "Not serializing invalid transport parameters: Client cannot send "
       "stateless reset token");
-  EXPECT_FALSE(ok);
 }
 
 TEST_P(TransportParametersTest, ParseClientParams) {

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

@@ -1508,7 +1508,8 @@ TEST_P(EndToEndTest, LargePostNoPacketLoss) {
   VerifyCleanConnection(true);
 }
 
-TEST_P(EndToEndTest, LargePostNoPacketLoss1sRTT) {
+// Marked as slow since this adds a real-clock one second of delay.
+TEST_P(EndToEndTest, QUICHE_SLOW_TEST(LargePostNoPacketLoss1sRTT)) {
   ASSERT_TRUE(Initialize());
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(1000));
 
@@ -1637,7 +1638,13 @@ TEST_P(EndToEndTest, LargePostNoPacketLossWithDelayAndReordering) {
             client_->SendCustomSynchronousRequest(headers, body));
 }
 
-TEST_P(EndToEndTest, AddressToken) {
+// TODO(b/214587920): make this test not rely on timeouts.
+TEST_P(EndToEndTest, QUICHE_SLOW_TEST(AddressToken)) {
+  client_config_.set_max_time_before_crypto_handshake(
+      QuicTime::Delta::FromSeconds(3));
+  client_config_.set_max_idle_time_before_crypto_handshake(
+      QuicTime::Delta::FromSeconds(1));
+
   client_extra_copts_.push_back(kTRTT);
   ASSERT_TRUE(Initialize());
   if (!version_.HasIetfQuicFrames()) {
@@ -1686,11 +1693,7 @@ TEST_P(EndToEndTest, AddressToken) {
     // QuicSentPacketManager::SetInitialRtt clamps the initial_rtt to between
     // [min_initial_rtt, max_initial_rtt].
     const QuicTime::Delta min_initial_rtt =
-        server_connection->sent_packet_manager().use_lower_min_irtt()
-            ? QuicTime::Delta::FromMicroseconds(
-                  kMinTrustedInitialRoundTripTimeUs)
-            : QuicTime::Delta::FromMicroseconds(
-                  kMinUntrustedInitialRoundTripTimeUs);
+        QuicTime::Delta::FromMicroseconds(kMinTrustedInitialRoundTripTimeUs);
     const QuicTime::Delta max_initial_rtt =
         QuicTime::Delta::FromMicroseconds(kMaxInitialRoundTripTimeUs);
     const QuicTime::Delta expected_initial_rtt =
@@ -1753,7 +1756,13 @@ TEST_P(EndToEndTest, AddressToken) {
 }
 
 // Verify that client does not reuse a source address token.
-TEST_P(EndToEndTest, AddressTokenNotReusedByClient) {
+// TODO(b/214587920): make this test not rely on timeouts.
+TEST_P(EndToEndTest, QUICHE_SLOW_TEST(AddressTokenNotReusedByClient)) {
+  client_config_.set_max_time_before_crypto_handshake(
+      QuicTime::Delta::FromSeconds(3));
+  client_config_.set_max_idle_time_before_crypto_handshake(
+      QuicTime::Delta::FromSeconds(1));
+
   ASSERT_TRUE(Initialize());
   if (!version_.HasIetfQuicFrames()) {
     return;
@@ -4254,7 +4263,8 @@ TEST_P(EndToEndTest, BadPacketHeaderFlags) {
 
 // Send a packet from the client with bad encrypted data.  The server should not
 // tear down the connection.
-TEST_P(EndToEndTest, BadEncryptedData) {
+// Marked as slow since it calls absl::SleepFor().
+TEST_P(EndToEndTest, QUICHE_SLOW_TEST(BadEncryptedData)) {
   ASSERT_TRUE(Initialize());
 
   // Start the connection.

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

@@ -1066,9 +1066,12 @@ TEST(HttpDecoderTestNoFixture, WebTransportStreamError) {
   EXPECT_CALL(visitor, OnWebTransportStreamFrameType(_, _));
   decoder.ProcessInput(input.data(), input.size());
 
-  EXPECT_CALL(visitor, OnError(_));
-  EXPECT_QUIC_BUG(decoder.ProcessInput(input.data(), input.size()),
-                  "HttpDecoder called after an indefinite-length frame");
+  EXPECT_QUIC_BUG(
+      {
+        EXPECT_CALL(visitor, OnError(_));
+        decoder.ProcessInput(input.data(), input.size());
+      },
+      "HttpDecoder called after an indefinite-length frame");
 }
 
 TEST_F(HttpDecoderTest, DecodeSettings) {

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

@@ -47,15 +47,6 @@ void QuicServerSessionBase::Initialize() {
 void QuicServerSessionBase::OnConfigNegotiated() {
   QuicSpdySession::OnConfigNegotiated();
 
-  const bool use_lower_min_irtt =
-      connection()->sent_packet_manager().use_lower_min_irtt();
-
-  if (!use_lower_min_irtt) {
-    if (!config()->HasReceivedConnectionOptions()) {
-      return;
-    }
-  }
-
   const CachedNetworkParameters* cached_network_params =
       crypto_stream_->PreviousCachedNetworkParams();
 
@@ -65,7 +56,7 @@ void QuicServerSessionBase::OnConfigNegotiated() {
   if (version().UsesTls() && cached_network_params != nullptr) {
     if (cached_network_params->serving_region() == serving_region_) {
       QUIC_CODE_COUNT(quic_server_received_network_params_at_same_region);
-      if ((!use_lower_min_irtt || config()->HasReceivedConnectionOptions()) &&
+      if (config()->HasReceivedConnectionOptions() &&
           ContainsQuicTag(config()->ReceivedConnectionOptions(), kTRTT)) {
         QUIC_DLOG(INFO)
             << "Server: Setting initial rtt to "
@@ -74,18 +65,15 @@ void QuicServerSessionBase::OnConfigNegotiated() {
         connection()->sent_packet_manager().SetInitialRtt(
             QuicTime::Delta::FromMilliseconds(
                 cached_network_params->min_rtt_ms()),
-            /*trusted=*/use_lower_min_irtt);
+            /*trusted=*/true);
       }
     } else {
       QUIC_CODE_COUNT(quic_server_received_network_params_at_different_region);
     }
   }
 
-  if (use_lower_min_irtt) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_use_lower_min_for_trusted_irtt, 1, 2);
-    if (!config()->HasReceivedConnectionOptions()) {
-      return;
-    }
+  if (!config()->HasReceivedConnectionOptions()) {
+    return;
   }
 
   if (GetQuicReloadableFlag(quic_enable_disable_resumption) &&

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

@@ -515,6 +515,12 @@ class QUIC_EXPORT_PRIVATE QuicSpdySession
   // in settings and accept remote settings for.
   virtual HttpDatagramSupport LocalHttpDatagramSupport();
 
+  // Sends any data which should be sent at the start of a connection, including
+  // the initial SETTINGS frame.  When using 0-RTT, this method is called twice:
+  // once when encryption is established, and again when 1-RTT keys are
+  // available.
+  void SendInitialData();
+
  private:
   friend class test::QuicSpdySessionPeer;
 
@@ -549,12 +555,6 @@ class QUIC_EXPORT_PRIVATE QuicSpdySession
   void CloseConnectionOnDuplicateHttp3UnidirectionalStreams(
       absl::string_view type);
 
-  // Sends any data which should be sent at the start of a connection, including
-  // the initial SETTINGS frame.  When using 0-RTT, this method is called twice:
-  // once when encryption is established, and again when 1-RTT keys are
-  // available.
-  void SendInitialData();
-
   void FillSettingsFrame();
 
   bool VerifySettingIsZeroOrOne(uint64_t id, uint64_t value);