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

package/third_party/quiche/quiche/http2/test_tools/payload_decoder_base_test_util.h

@@ -21,10 +21,10 @@
 #include "quiche/http2/test_tools/frame_parts.h"
 #include "quiche/http2/test_tools/http2_constants_test_util.h"
 #include "quiche/http2/test_tools/http2_frame_builder.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/platform/api/quiche_logging.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 namespace http2 {
 namespace test {
@@ -192,8 +192,8 @@ class QUICHE_NO_EXPORT AbstractPayloadDecoderTest
   AssertionResult DecodePayloadAndValidateSeveralWays(
       absl::string_view payload, const FrameParts& expected) {
     auto validator = [&expected, this]() -> AssertionResult {
-      VERIFY_FALSE(listener_.IsInProgress());
-      VERIFY_EQ(1u, listener_.size());
+      HTTP2_VERIFY_FALSE(listener_.IsInProgress());
+      HTTP2_VERIFY_EQ(1u, listener_.size());
       return expected.VerifyEquals(*listener_.frame(0));
     };
     return PayloadDecoderBaseTest::DecodePayloadAndValidateSeveralWays(
@@ -221,15 +221,15 @@ class QUICHE_NO_EXPORT AbstractPayloadDecoderTest
                     DecodeStatus status) -> ::testing::AssertionResult {
       QUICHE_DVLOG(2) << "VerifyDetectsFrameSizeError validator; status="
                       << status << "; input.Remaining=" << input.Remaining();
-      VERIFY_EQ(DecodeStatus::kDecodeError, status);
-      VERIFY_FALSE(listener_.IsInProgress());
-      VERIFY_EQ(1u, listener_.size());
+      HTTP2_VERIFY_EQ(DecodeStatus::kDecodeError, status);
+      HTTP2_VERIFY_FALSE(listener_.IsInProgress());
+      HTTP2_VERIFY_EQ(1u, listener_.size());
       const FrameParts* frame = listener_.frame(0);
-      VERIFY_EQ(header, frame->GetFrameHeader());
-      VERIFY_TRUE(frame->GetHasFrameSizeError());
+      HTTP2_VERIFY_EQ(header, frame->GetFrameHeader());
+      HTTP2_VERIFY_TRUE(frame->GetHasFrameSizeError());
       // Verify did not get OnPaddingTooLong, as we should only ever produce
       // one of these two errors for a single frame.
-      VERIFY_FALSE(frame->GetOptMissingLength());
+      HTTP2_VERIFY_FALSE(frame->GetOptMissingLength());
       return validator(input, status);
     };
     return PayloadDecoderBaseTest::DecodePayloadAndValidateSeveralWays(
@@ -250,10 +250,11 @@ class QUICHE_NO_EXPORT AbstractPayloadDecoderTest
     // type AND are those that affect the decoding of the payload (otherwise,
     // the flag shouldn't be required).
     Http2FrameType frame_type = DecoderPeer::FrameType();
-    VERIFY_EQ(required_flags,
-              required_flags & KnownFlagsMaskForFrameType(frame_type));
-    VERIFY_EQ(required_flags,
-              required_flags & DecoderPeer::FlagsAffectingPayloadDecoding());
+    HTTP2_VERIFY_EQ(required_flags,
+                    required_flags & KnownFlagsMaskForFrameType(frame_type));
+    HTTP2_VERIFY_EQ(
+        required_flags,
+        required_flags & DecoderPeer::FlagsAffectingPayloadDecoding());
 
     if (0 !=
         (Http2FrameFlag::PADDED & KnownFlagsMaskForFrameType(frame_type))) {
@@ -264,7 +265,7 @@ class QUICHE_NO_EXPORT AbstractPayloadDecoderTest
         required_flags |= Http2FrameFlag::PADDED;
       }
     } else {
-      VERIFY_EQ(0, total_pad_length);
+      HTTP2_VERIFY_EQ(0, total_pad_length);
     }
 
     bool validated = false;
@@ -291,10 +292,11 @@ class QUICHE_NO_EXPORT AbstractPayloadDecoderTest
       // checking stream ids.
       uint32_t stream_id = RandStreamId();
       Http2FrameHeader header(fb.size(), frame_type, flags, stream_id);
-      VERIFY_SUCCESS(VerifyDetectsFrameSizeError(fb.buffer(), header, nullptr));
+      HTTP2_VERIFY_SUCCESS(
+          VerifyDetectsFrameSizeError(fb.buffer(), header, nullptr));
       validated = true;
     }
-    VERIFY_TRUE(validated);
+    HTTP2_VERIFY_TRUE(validated);
     return ::testing::AssertionSuccess();
   }
 
@@ -304,8 +306,8 @@ class QUICHE_NO_EXPORT AbstractPayloadDecoderTest
       const ApproveSize& approve_size) {
     Http2FrameType frame_type = DecoderPeer::FrameType();
     uint8_t known_flags = KnownFlagsMaskForFrameType(frame_type);
-    VERIFY_EQ(0, known_flags & Http2FrameFlag::PADDED);
-    VERIFY_EQ(0, required_flags & Http2FrameFlag::PADDED);
+    HTTP2_VERIFY_EQ(0, known_flags & Http2FrameFlag::PADDED);
+    HTTP2_VERIFY_EQ(0, required_flags & Http2FrameFlag::PADDED);
     return VerifyDetectsMultipleFrameSizeErrors(
         required_flags, unpadded_payload, approve_size, 0);
   }
@@ -381,15 +383,16 @@ class QUICHE_NO_EXPORT AbstractPaddablePayloadDecoderTest
         [header, expected_missing_length, &listener](
             const DecodeBuffer&,
             DecodeStatus status) -> ::testing::AssertionResult {
-      VERIFY_EQ(DecodeStatus::kDecodeError, status);
-      VERIFY_FALSE(listener.IsInProgress());
-      VERIFY_EQ(1u, listener.size());
+      HTTP2_VERIFY_EQ(DecodeStatus::kDecodeError, status);
+      HTTP2_VERIFY_FALSE(listener.IsInProgress());
+      HTTP2_VERIFY_EQ(1u, listener.size());
       const FrameParts* frame = listener.frame(0);
-      VERIFY_EQ(header, frame->GetFrameHeader());
-      VERIFY_TRUE(frame->GetOptMissingLength());
-      VERIFY_EQ(expected_missing_length, frame->GetOptMissingLength().value());
+      HTTP2_VERIFY_EQ(header, frame->GetFrameHeader());
+      HTTP2_VERIFY_TRUE(frame->GetOptMissingLength());
+      HTTP2_VERIFY_EQ(expected_missing_length,
+                      frame->GetOptMissingLength().value());
       // Verify did not get OnFrameSizeError.
-      VERIFY_FALSE(frame->GetHasFrameSizeError());
+      HTTP2_VERIFY_FALSE(frame->GetHasFrameSizeError());
       return ::testing::AssertionSuccess();
     };
     return PayloadDecoderBaseTest::DecodePayloadAndValidateSeveralWays(

package/third_party/quiche/quiche/http2/test_tools/{random_decoder_test.cc → random_decoder_test_base.cc}

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 
 #include <stddef.h>
 
@@ -12,9 +12,9 @@
 #include "quiche/http2/decoder/decode_buffer.h"
 #include "quiche/http2/decoder/decode_status.h"
 #include "quiche/http2/http2_constants.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionResult;
 
@@ -81,7 +81,7 @@ AssertionResult RandomDecoderTest::DecodeAndValidateSeveralWays(
     // Fast decode (no stopping unless decoder does so).
     DecodeBuffer input(original->cursor(), original_remaining);
     QUICHE_VLOG(2) << "DecodeSegmentsAndValidate with SelectRemaining";
-    VERIFY_SUCCESS(
+    HTTP2_VERIFY_SUCCESS(
         DecodeSegmentsAndValidate(&input, SelectRemaining(), validator))
         << "\nFailed with SelectRemaining; input.Offset=" << input.Offset()
         << "; input.Remaining=" << input.Remaining();
@@ -91,19 +91,21 @@ AssertionResult RandomDecoderTest::DecodeAndValidateSeveralWays(
     // Decode again, one byte at a time.
     DecodeBuffer input(original->cursor(), original_remaining);
     QUICHE_VLOG(2) << "DecodeSegmentsAndValidate with SelectOne";
-    VERIFY_SUCCESS(DecodeSegmentsAndValidate(&input, SelectOne(), validator))
+    HTTP2_VERIFY_SUCCESS(
+        DecodeSegmentsAndValidate(&input, SelectOne(), validator))
         << "\nFailed with SelectOne; input.Offset=" << input.Offset()
         << "; input.Remaining=" << input.Remaining();
-    VERIFY_EQ(first_consumed, input.Offset()) << "\nFailed with SelectOne";
+    HTTP2_VERIFY_EQ(first_consumed, input.Offset())
+        << "\nFailed with SelectOne";
   }
   if (original_remaining <= 20) {
     // Decode again, one or zero bytes at a time.
     DecodeBuffer input(original->cursor(), original_remaining);
     QUICHE_VLOG(2) << "DecodeSegmentsAndValidate with SelectZeroAndOne";
-    VERIFY_SUCCESS(DecodeSegmentsAndValidate(
+    HTTP2_VERIFY_SUCCESS(DecodeSegmentsAndValidate(
         &input, SelectZeroAndOne(return_non_zero_on_first), validator))
         << "\nFailed with SelectZeroAndOne";
-    VERIFY_EQ(first_consumed, input.Offset())
+    HTTP2_VERIFY_EQ(first_consumed, input.Offset())
         << "\nFailed with SelectZeroAndOne; input.Offset=" << input.Offset()
         << "; input.Remaining=" << input.Remaining();
   }
@@ -111,13 +113,14 @@ AssertionResult RandomDecoderTest::DecodeAndValidateSeveralWays(
     // Decode again, with randomly selected segment sizes.
     DecodeBuffer input(original->cursor(), original_remaining);
     QUICHE_VLOG(2) << "DecodeSegmentsAndValidate with SelectRandom";
-    VERIFY_SUCCESS(DecodeSegmentsAndValidate(
+    HTTP2_VERIFY_SUCCESS(DecodeSegmentsAndValidate(
         &input, SelectRandom(return_non_zero_on_first), validator))
         << "\nFailed with SelectRandom; input.Offset=" << input.Offset()
         << "; input.Remaining=" << input.Remaining();
-    VERIFY_EQ(first_consumed, input.Offset()) << "\nFailed with SelectRandom";
+    HTTP2_VERIFY_EQ(first_consumed, input.Offset())
+        << "\nFailed with SelectRandom";
   }
-  VERIFY_EQ(original_remaining, original->Remaining());
+  HTTP2_VERIFY_EQ(original_remaining, original->Remaining());
   original->AdvanceCursor(first_consumed);
   QUICHE_VLOG(1) << "DecodeAndValidateSeveralWays - SUCCESS";
   return ::testing::AssertionSuccess();

package/third_party/quiche/quiche/http2/test_tools/{random_decoder_test.h → random_decoder_test_base.h}

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef QUICHE_HTTP2_TEST_TOOLS_RANDOM_DECODER_TEST_H_
-#define QUICHE_HTTP2_TEST_TOOLS_RANDOM_DECODER_TEST_H_
+#ifndef QUICHE_HTTP2_TEST_TOOLS_RANDOM_DECODER_TEST_BASE_H_
+#define QUICHE_HTTP2_TEST_TOOLS_RANDOM_DECODER_TEST_BASE_H_
 
 // RandomDecoderTest is a base class for tests of decoding various kinds
 // of HTTP/2 and HPACK encodings.
@@ -21,10 +21,10 @@
 #include "quiche/http2/decoder/decode_buffer.h"
 #include "quiche/http2/decoder/decode_status.h"
 #include "quiche/http2/test_tools/http2_random.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 namespace http2 {
 namespace test {
@@ -55,7 +55,7 @@ void CorruptEnum(T* out, Http2Random* rng) {
 
 // Base class for tests of the ability to decode a sequence of bytes with
 // various boundaries between the DecodeBuffers provided to the decoder.
-class QUICHE_NO_EXPORT RandomDecoderTest : public QuicheTest {
+class QUICHE_NO_EXPORT RandomDecoderTest : public quiche::test::QuicheTest {
  public:
   // SelectSize returns the size of the next DecodeBuffer to be passed to the
   // decoder. Note that RandomDecoderTest allows that size to be zero, though
@@ -75,10 +75,6 @@ class QUICHE_NO_EXPORT RandomDecoderTest : public QuicheTest {
   RandomDecoderTest();
 
  protected:
-  // TODO(jamessynge): Modify StartDecoding, etc. to (somehow) return
-  // AssertionResult so that the VERIFY_* methods exported from
-  // gunit_helpers.h can be widely used.
-
   // Start decoding; call allows sub-class to Reset the decoder, or deal with
   // the first byte if that is done in a unique fashion.  Might be called with
   // a zero byte buffer.
@@ -178,8 +174,8 @@ class QUICHE_NO_EXPORT RandomDecoderTest : public QuicheTest {
   static Validator ValidateDoneAndEmpty(const Validator& wrapped) {
     return [wrapped](const DecodeBuffer& input,
                      DecodeStatus status) -> AssertionResult {
-      VERIFY_EQ(status, DecodeStatus::kDecodeDone);
-      VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset();
+      HTTP2_VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+      HTTP2_VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset();
       if (wrapped) {
         return wrapped(input, status);
       }
@@ -189,8 +185,8 @@ class QUICHE_NO_EXPORT RandomDecoderTest : public QuicheTest {
   static Validator ValidateDoneAndEmpty(NoArgValidator wrapped) {
     return [wrapped](const DecodeBuffer& input,
                      DecodeStatus status) -> AssertionResult {
-      VERIFY_EQ(status, DecodeStatus::kDecodeDone);
-      VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset();
+      HTTP2_VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+      HTTP2_VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset();
       if (wrapped) {
         return wrapped();
       }
@@ -212,8 +208,9 @@ class QUICHE_NO_EXPORT RandomDecoderTest : public QuicheTest {
                                          const Validator& wrapped) {
     return [wrapped, offset](const DecodeBuffer& input,
                              DecodeStatus status) -> AssertionResult {
-      VERIFY_EQ(status, DecodeStatus::kDecodeDone);
-      VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining();
+      HTTP2_VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+      HTTP2_VERIFY_EQ(offset, input.Offset())
+          << "\nRemaining=" << input.Remaining();
       if (wrapped) {
         return wrapped(input, status);
       }
@@ -224,8 +221,9 @@ class QUICHE_NO_EXPORT RandomDecoderTest : public QuicheTest {
                                          NoArgValidator wrapped) {
     return [wrapped, offset](const DecodeBuffer& input,
                              DecodeStatus status) -> AssertionResult {
-      VERIFY_EQ(status, DecodeStatus::kDecodeDone);
-      VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining();
+      HTTP2_VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+      HTTP2_VERIFY_EQ(offset, input.Offset())
+          << "\nRemaining=" << input.Remaining();
       if (wrapped) {
         return wrapped();
       }
@@ -254,4 +252,4 @@ class QUICHE_NO_EXPORT RandomDecoderTest : public QuicheTest {
 }  // namespace test
 }  // namespace http2
 
-#endif  // QUICHE_HTTP2_TEST_TOOLS_RANDOM_DECODER_TEST_H_
+#endif  // QUICHE_HTTP2_TEST_TOOLS_RANDOM_DECODER_TEST_BASE_H_

package/third_party/quiche/quiche/http2/test_tools/{random_decoder_test_test.cc → random_decoder_test_base_test.cc}

@@ -1,4 +1,4 @@
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 
 #include <stddef.h>
 

package/third_party/quiche/quiche/http2/test_tools/verify_macros.h

@@ -0,0 +1,32 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_HTTP2_TEST_TOOLS_VERIFY_MACROS_H_
+#define QUICHE_HTTP2_TEST_TOOLS_VERIFY_MACROS_H_
+
+#include "quiche/common/platform/api/quiche_test.h"
+
+#define HTTP2_VERIFY_CORE(value, str)            \
+  if ((value))                                   \
+    ;                                            \
+  else                                           \
+    return ::testing::AssertionFailure()         \
+           << __FILE__ << ":" << __LINE__ << " " \
+           << "Failed to verify that '" << str << "'"
+
+#define HTTP2_VERIFY_TRUE(value) HTTP2_VERIFY_CORE(value, #value)
+#define HTTP2_VERIFY_FALSE(value) HTTP2_VERIFY_CORE(!value, "!" #value)
+#define HTTP2_VERIFY_SUCCESS HTTP2_VERIFY_TRUE
+#define HTTP2_VERIFY_EQ(value1, value2) \
+  HTTP2_VERIFY_CORE((value1) == (value2), #value1 "==" #value2)
+#define HTTP2_VERIFY_NE(value1, value2) \
+  HTTP2_VERIFY_CORE((value1) != (value2), #value1 "!=" #value2)
+#define HTTP2_VERIFY_LE(value1, value2) \
+  HTTP2_VERIFY_CORE((value1) <= (value2), #value1 "<=" #value2)
+#define HTTP2_VERIFY_LT(value1, value2) \
+  HTTP2_VERIFY_CORE((value1) < (value2), #value1 "<" #value2)
+#define HTTP2_VERIFY_GT(value1, value2) \
+  HTTP2_VERIFY_CORE((value1) > (value2), #value1 ">" #value2)
+
+#endif  // QUICHE_HTTP2_TEST_TOOLS_VERIFY_MACROS_H_

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

@@ -16,6 +16,7 @@
 #include "quiche/quic/platform/api/quic_flag_utils.h"
 #include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/print_elements.h"
 
 namespace quic {
@@ -221,7 +222,7 @@ Limits<QuicByteCount> Bbr2Sender::GetCwndLimitsByMode() const {
     case Bbr2Mode::PROBE_RTT:
       return probe_rtt_.GetCwndLimits();
     default:
-      QUIC_NOTREACHED();
+      QUICHE_NOTREACHED();
       return Unlimited<QuicByteCount>();
   }
 }

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

@@ -127,7 +127,8 @@ class Bbr2SimulatorTest : public QuicTest {
   }
 
   void SetUp() override {
-    if (GetQuicFlag(FLAGS_quic_bbr2_test_regression_mode) == "regress") {
+    if (quiche::GetQuicheCommandLineFlag(
+            FLAGS_quic_bbr2_test_regression_mode) == "regress") {
       SendAlgorithmTestResult expected;
       ASSERT_TRUE(LoadSendAlgorithmTestResult(&expected));
       random_seed_ = expected.random_seed();
@@ -140,7 +141,7 @@ class Bbr2SimulatorTest : public QuicTest {
 
   ~Bbr2SimulatorTest() override {
     const std::string regression_mode =
-        GetQuicFlag(FLAGS_quic_bbr2_test_regression_mode);
+        quiche::GetQuicheCommandLineFlag(FLAGS_quic_bbr2_test_regression_mode);
     const QuicTime::Delta simulated_duration =
         SimulatedNow() - QuicTime::Zero();
     if (regression_mode == "record") {

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

@@ -108,7 +108,8 @@ class BbrSenderTest : public QuicTest {
   }
 
   void SetUp() override {
-    if (GetQuicFlag(FLAGS_quic_bbr_test_regression_mode) == "regress") {
+    if (quiche::GetQuicheCommandLineFlag(FLAGS_quic_bbr_test_regression_mode) ==
+        "regress") {
       SendAlgorithmTestResult expected;
       ASSERT_TRUE(LoadSendAlgorithmTestResult(&expected));
       random_seed_ = expected.random_seed();
@@ -121,7 +122,7 @@ class BbrSenderTest : public QuicTest {
 
   ~BbrSenderTest() {
     const std::string regression_mode =
-        GetQuicFlag(FLAGS_quic_bbr_test_regression_mode);
+        quiche::GetQuicheCommandLineFlag(FLAGS_quic_bbr_test_regression_mode);
     const QuicTime::Delta simulated_duration = clock_->Now() - QuicTime::Zero();
     if (regression_mode == "record") {
       RecordSendAlgorithmTestResult(random_seed_,

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

@@ -39,14 +39,14 @@ void RttStats::ExpireSmoothedMetrics() {
 }
 
 // Updates the RTT based on a new sample.
-void RttStats::UpdateRtt(QuicTime::Delta send_delta, QuicTime::Delta ack_delay,
+bool RttStats::UpdateRtt(QuicTime::Delta send_delta, QuicTime::Delta ack_delay,
                          QuicTime now) {
   if (send_delta.IsInfinite() || send_delta <= QuicTime::Delta::Zero()) {
     QUIC_LOG_FIRST_N(WARNING, 3)
         << "Ignoring measured send_delta, because it's is "
         << "either infinite, zero, or negative.  send_delta = "
         << send_delta.ToMicroseconds();
-    return;
+    return false;
   }
 
   last_update_time_ = now;
@@ -92,6 +92,7 @@ void RttStats::UpdateRtt(QuicTime::Delta send_delta, QuicTime::Delta ack_delay,
     QUIC_DVLOG(1) << " smoothed_rtt(us):" << smoothed_rtt_.ToMicroseconds()
                   << " mean_deviation(us):" << mean_deviation_.ToMicroseconds();
   }
+  return true;
 }
 
 void RttStats::OnConnectionMigration() {

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

@@ -47,7 +47,8 @@ class QUIC_EXPORT_PRIVATE RttStats {
 
   // Updates the RTT from an incoming ack which is received |send_delta| after
   // the packet is sent and the peer reports the ack being delayed |ack_delay|.
-  void UpdateRtt(QuicTime::Delta send_delta, QuicTime::Delta ack_delay,
+  // Returns true if RTT was updated, and false if the sample was ignored.
+  bool UpdateRtt(QuicTime::Delta send_delta, QuicTime::Delta ack_delay,
                  QuicTime now);
 
   // Causes the smoothed_rtt to be increased to the latest_rtt if the latest_rtt

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

@@ -6,13 +6,9 @@
 
 #include <cmath>
 
-#include "quiche/quic/platform/api/quic_logging.h"
-#include "quiche/quic/platform/api/quic_mock_log.h"
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
-#include "quiche/quic/test_tools/rtt_stats_peer.h"
 
-using testing::_;
 using testing::Message;
 
 namespace quic {
@@ -141,9 +137,6 @@ TEST_F(RttStatsTest, ExpireSmoothedMetrics) {
 }
 
 TEST_F(RttStatsTest, UpdateRttWithBadSendDeltas) {
-  // Make sure we ignore bad RTTs.
-  CREATE_QUIC_MOCK_LOG(log);
-
   QuicTime::Delta initial_rtt = QuicTime::Delta::FromMilliseconds(10);
   rtt_stats_.UpdateRtt(initial_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
   EXPECT_EQ(initial_rtt, rtt_stats_.min_rtt());
@@ -153,16 +146,12 @@ TEST_F(RttStatsTest, UpdateRttWithBadSendDeltas) {
   bad_send_deltas.push_back(QuicTime::Delta::Zero());
   bad_send_deltas.push_back(QuicTime::Delta::Infinite());
   bad_send_deltas.push_back(QuicTime::Delta::FromMicroseconds(-1000));
-  log.StartCapturingLogs();
 
   for (QuicTime::Delta bad_send_delta : bad_send_deltas) {
     SCOPED_TRACE(Message() << "bad_send_delta = "
                            << bad_send_delta.ToMicroseconds());
-    if (QUIC_LOG_WARNING_IS_ON()) {
-      EXPECT_QUIC_LOG_CALL_CONTAINS(log, WARNING, "Ignoring");
-    }
-    rtt_stats_.UpdateRtt(bad_send_delta, QuicTime::Delta::Zero(),
-                         QuicTime::Zero());
+    EXPECT_FALSE(rtt_stats_.UpdateRtt(bad_send_delta, QuicTime::Delta::Zero(),
+                                      QuicTime::Zero()));
     EXPECT_EQ(initial_rtt, rtt_stats_.min_rtt());
     EXPECT_EQ(initial_rtt, rtt_stats_.smoothed_rtt());
   }

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

@@ -79,8 +79,12 @@ PublicKeyType PublicKeyTypeFromKey(EVP_PKEY* public_key) {
   }
 }
 
+}  // namespace
+
 PublicKeyType PublicKeyTypeFromSignatureAlgorithm(
     uint16_t signature_algorithm) {
+  // This should be kept in sync with the list in
+  // SupportedSignatureAlgorithmsForQuic().
   switch (signature_algorithm) {
     case SSL_SIGN_RSA_PSS_RSAE_SHA256:
       return PublicKeyType::kRsa;
@@ -95,6 +99,17 @@ PublicKeyType PublicKeyTypeFromSignatureAlgorithm(
   }
 }
 
+QUIC_EXPORT_PRIVATE QuicSignatureAlgorithmVector
+SupportedSignatureAlgorithmsForQuic() {
+  // This should be kept in sync with the list in
+  // PublicKeyTypeFromSignatureAlgorithm().
+  return QuicSignatureAlgorithmVector{
+      SSL_SIGN_ED25519, SSL_SIGN_ECDSA_SECP256R1_SHA256,
+      SSL_SIGN_ECDSA_SECP384R1_SHA384, SSL_SIGN_RSA_PSS_RSAE_SHA256};
+}
+
+namespace {
+
 std::string AttributeNameToString(const CBS& oid_cbs) {
   absl::string_view oid = CbsToStringPiece(oid_cbs);
 

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

@@ -43,6 +43,13 @@ enum class PublicKeyType {
   kUnknown,
 };
 QUIC_EXPORT_PRIVATE std::string PublicKeyTypeToString(PublicKeyType type);
+QUIC_EXPORT_PRIVATE PublicKeyType
+PublicKeyTypeFromSignatureAlgorithm(uint16_t signature_algorithm);
+
+// Returns the list of the signature algorithms that can be processed by
+// CertificateView::VerifySignature() and CertificatePrivateKey::Sign().
+QUIC_EXPORT_PRIVATE QuicSignatureAlgorithmVector
+SupportedSignatureAlgorithmsForQuic();
 
 // CertificateView represents a parsed version of a single X.509 certificate. As
 // the word "view" implies, it does not take ownership of the underlying strings

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

@@ -4,9 +4,11 @@
 
 #include "quiche/quic/core/crypto/certificate_view.h"
 
+#include <limits>
 #include <memory>
 #include <sstream>
 
+#include "absl/algorithm/container.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/string_view.h"
 #include "openssl/base.h"
@@ -209,6 +211,20 @@ TEST(CertificateViewTest, NameAttribute) {
             X509NameAttributeToString(StringPieceToCbs(invalid_oid)));
 }
 
+TEST(CertificateViewTest, SupportedSignatureAlgorithmsForQuicIsUpToDate) {
+  QuicSignatureAlgorithmVector supported =
+      SupportedSignatureAlgorithmsForQuic();
+  for (int i = 0; i < std::numeric_limits<uint16_t>::max(); i++) {
+    uint16_t sigalg = static_cast<uint16_t>(i);
+    PublicKeyType key_type = PublicKeyTypeFromSignatureAlgorithm(sigalg);
+    if (absl::c_find(supported, sigalg) == supported.end()) {
+      EXPECT_EQ(key_type, PublicKeyType::kUnknown);
+    } else {
+      EXPECT_NE(key_type, PublicKeyType::kUnknown);
+    }
+  }
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic

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

@@ -301,6 +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 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/crypto/proof_source.h

@@ -173,7 +173,7 @@ class QUIC_EXPORT_PRIVATE ProofSource {
   //
   // If returns a non-empty list, ComputeTlsSignature will only be called with a
   // algorithm in the list.
-  virtual absl::InlinedVector<uint16_t, 8> SupportedTlsSignatureAlgorithms()
+  virtual QuicSignatureAlgorithmVector SupportedTlsSignatureAlgorithms()
       const = 0;
 
   class QUIC_EXPORT_PRIVATE DecryptCallback {
@@ -219,7 +219,7 @@ class QUIC_EXPORT_PRIVATE ProofSource {
     // |in|. If decryption fails, the callback is invoked with an empty
     // vector.
     virtual void Decrypt(absl::string_view in,
-                         std::unique_ptr<DecryptCallback> callback) = 0;
+                         std::shared_ptr<DecryptCallback> callback) = 0;
   };
 
   // Returns the TicketCrypter used for encrypting and decrypting TLS

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

@@ -103,11 +103,9 @@ void ProofSourceX509::ComputeTlsSignature(
   callback->Run(/*ok=*/!signature.empty(), signature, nullptr);
 }
 
-absl::InlinedVector<uint16_t, 8>
-ProofSourceX509::SupportedTlsSignatureAlgorithms() const {
-  // Let ComputeTlsSignature() report an error if a bad signature algorithm is
-  // requested.
-  return {};
+QuicSignatureAlgorithmVector ProofSourceX509::SupportedTlsSignatureAlgorithms()
+    const {
+  return SupportedSignatureAlgorithmsForQuic();
 }
 
 ProofSource::TicketCrypter* ProofSourceX509::GetTicketCrypter() {

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

@@ -43,8 +43,7 @@ class QUIC_EXPORT_PRIVATE ProofSourceX509 : public ProofSource {
       const QuicSocketAddress& client_address, const std::string& hostname,
       uint16_t signature_algorithm, absl::string_view in,
       std::unique_ptr<SignatureCallback> callback) override;
-  absl::InlinedVector<uint16_t, 8> SupportedTlsSignatureAlgorithms()
-      const override;
+  QuicSignatureAlgorithmVector SupportedTlsSignatureAlgorithms() const override;
   TicketCrypter* GetTicketCrypter() override;
 
   // Adds a certificate chain to the verifier.  Returns false if the chain is

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

@@ -706,7 +706,7 @@ void QuicCryptoServerConfig::ProcessClientHello(
         params,
     quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig> signed_config,
     QuicByteCount total_framing_overhead, QuicByteCount chlo_packet_size,
-    std::unique_ptr<ProcessClientHelloResultCallback> done_cb) const {
+    std::shared_ptr<ProcessClientHelloResultCallback> done_cb) const {
   QUICHE_DCHECK(done_cb);
   auto context = std::make_unique<ProcessClientHelloContext>(
       validate_chlo_result, reject_only, connection_id, server_address,

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

@@ -335,7 +335,7 @@ class QUIC_EXPORT_PRIVATE QuicCryptoServerConfig {
       quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
           signed_config,
       QuicByteCount total_framing_overhead, QuicByteCount chlo_packet_size,
-      std::unique_ptr<ProcessClientHelloResultCallback> done_cb) const;
+      std::shared_ptr<ProcessClientHelloResultCallback> done_cb) const;
 
   // BuildServerConfigUpdateMessage invokes |cb| with a SCUP message containing
   // the current primary config, an up to date source-address token, and cert
@@ -587,7 +587,7 @@ class QUIC_EXPORT_PRIVATE QuicCryptoServerConfig {
         quiche::QuicheReferenceCountedPointer<QuicSignedServerConfig>
             signed_config,
         QuicByteCount total_framing_overhead, QuicByteCount chlo_packet_size,
-        std::unique_ptr<ProcessClientHelloResultCallback> done_cb)
+        std::shared_ptr<ProcessClientHelloResultCallback> done_cb)
         : validate_chlo_result_(validate_chlo_result),
           reject_only_(reject_only),
           connection_id_(connection_id),
@@ -674,7 +674,7 @@ class QUIC_EXPORT_PRIVATE QuicCryptoServerConfig {
         signed_config_;
     const QuicByteCount total_framing_overhead_;
     const QuicByteCount chlo_packet_size_;
-    std::unique_ptr<ProcessClientHelloResultCallback> done_cb_;
+    std::shared_ptr<ProcessClientHelloResultCallback> done_cb_;
   };
 
   // Callback class for bridging between ProcessClientHello and