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

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_command_line_flags_impl.cc

@@ -0,0 +1,41 @@
+// 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.
+
+#include "quiche_platform_impl/quiche_command_line_flags_impl.h"
+
+#include <iostream>
+
+#include "absl/flags/parse.h"
+#include "absl/flags/usage.h"
+
+namespace quiche {
+
+static void SetUsage(absl::string_view usage) {
+  static bool usage_set = false;
+  if (!usage_set) {
+    absl::SetProgramUsageMessage(usage);
+    usage_set = true;
+  }
+}
+
+std::vector<std::string> QuicheParseCommandLineFlagsImpl(
+    const char* usage, int argc, const char* const* argv, bool /*parse_only*/) {
+  SetUsage(usage);
+  std::vector<char*> parsed =
+      absl::ParseCommandLine(argc, const_cast<char**>(argv));
+  std::vector<std::string> result;
+  result.reserve(parsed.size());
+  // Remove the first argument, which is the name of the binary.
+  for (size_t i = 1; i < parsed.size(); i++) {
+    result.push_back(std::string(parsed[i]));
+  }
+  return result;
+}
+
+void QuichePrintCommandLineFlagHelpImpl(const char* usage) {
+  SetUsage(usage);
+  std::cerr << absl::ProgramUsageMessage() << std::endl;
+}
+
+}  // namespace quiche

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_command_line_flags_impl.h

@@ -0,0 +1,33 @@
+// 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_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_COMMAND_LINE_FLAGS_IMPL_H_
+#define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_COMMAND_LINE_FLAGS_IMPL_H_
+
+#include "absl/flags/flag.h"
+
+#define DEFINE_QUICHE_COMMAND_LINE_FLAG_IMPL(type, name, default_value, help) \
+  ABSL_FLAG(type, name, default_value, help)
+
+namespace quiche {
+
+template <typename T>
+T GetQuicheCommandLineFlag(const absl::Flag<T>& flag) {
+  return absl::GetFlag(flag);
+}
+
+std::vector<std::string> QuicheParseCommandLineFlagsImpl(
+    const char* usage, int argc, const char* const* argv,
+    bool parse_only = false);
+
+void QuichePrintCommandLineFlagHelpImpl(const char* usage);
+
+}  // namespace quiche
+
+template <typename T>
+T GetQuicheFlagImpl(const absl::Flag<T>& flag) {
+  return absl::GetFlag(flag);
+}
+
+#endif  // QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_COMMAND_LINE_FLAGS_IMPL_H_

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_expect_bug_impl.h

@@ -0,0 +1,15 @@
+// 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_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_EXPECT_BUG_IMPL_H_
+#define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_EXPECT_BUG_IMPL_H_
+
+#include "quiche/common/platform/api/quiche_test.h"
+
+#define EXPECT_QUICHE_BUG_IMPL(statement, regex) \
+  EXPECT_QUICHE_DEBUG_DEATH(statement, regex)
+#define EXPECT_QUICHE_PEER_BUG_IMPL(statement, regex) \
+  EXPECT_QUICHE_DEBUG_DEATH(statement, regex)
+
+#endif  // QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_EXPECT_BUG_IMPL_H_

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.h

@@ -3,9 +3,10 @@
 // found in the LICENSE file.
 
 // This file does not actually implement logging, it merely provides enough of
-// logging code for QUICHE to compile.  QUICHE embedders are encouraged to
-// override this file with their own logic.  If at some point logging becomes a
-// part of Abseil, this file will likely start using that instead.
+// logging code for QUICHE to compile and pass the unit tests.  QUICHE embedders
+// are encouraged to override this file with their own logic.  If at some point
+// logging becomes a part of Abseil, this file will likely start using that
+// instead.
 
 #ifndef QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_LOGGING_IMPL_H_
 #define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_LOGGING_IMPL_H_
@@ -17,9 +18,17 @@
 
 #include "absl/base/attributes.h"
 #include "quiche/common/platform/api/quiche_export.h"
+#include "quiche_platform_impl/quiche_stack_trace_impl.h"
 
 namespace quiche {
 
+class QUICHE_EXPORT_PRIVATE LogStreamVoidHelper {
+ public:
+  // This operator has lower precedence than << but higher than ?:, which is
+  // useful for implementing QUICHE_DISREGARD_LOG_STREAM below.
+  constexpr void operator&(std::ostream&) {}
+};
+
 // NoopLogSink provides a log sink that does not put the data that it logs
 // anywhere.
 class QUICHE_EXPORT_PRIVATE NoopLogSink {
@@ -34,9 +43,8 @@ class QUICHE_EXPORT_PRIVATE NoopLogSink {
 
   constexpr std::ostream& stream() { return stream_; }
 
-  // This operator has lower precedence than << but higher than ?:, which is
-  // useful for implementing QUICHE_DISREGARD_LOG_STREAM below.
-  void operator&(std::ostream&) {}
+ protected:
+  std::string str() { return stream_.str(); }
 
  private:
   std::stringstream stream_;
@@ -46,77 +54,103 @@ class QUICHE_EXPORT_PRIVATE NoopLogSink {
 // to compile due to the "failed to return value from non-void function" error.
 class QUICHE_EXPORT_PRIVATE FatalLogSink : public NoopLogSink {
  public:
-  ABSL_ATTRIBUTE_NORETURN ~FatalLogSink() { abort(); }
+  ABSL_ATTRIBUTE_NORETURN ~FatalLogSink() {
+    std::cerr << str() << std::endl;
+    std::cerr << quiche::QuicheStackTraceImpl() << std::endl;
+    abort();
+  }
+};
+
+class QUICHE_EXPORT_PRIVATE CheckLogSink : public NoopLogSink {
+ public:
+  CheckLogSink(bool condition) : condition_(condition) {}
+  ~CheckLogSink() {
+    if (!condition_) {
+      std::cerr << "Check failed: " << str() << std::endl;
+      std::cerr << quiche::QuicheStackTraceImpl() << std::endl;
+      abort();
+    }
+  }
+
+ private:
+  const bool condition_;
 };
 
 }  // namespace quiche
 
-#define QUICHE_DVLOG_IMPL(verbose_level) \
-  ::quiche::NoopLogSink(#verbose_level).stream()
+// This is necessary because we sometimes call QUICHE_DCHECK inside constexpr
+// functions, and then write non-constexpr expressions into the resulting log.
+#define QUICHE_CONDITIONAL_LOG_STREAM(stream, condition) \
+  !(condition) ? (void)0 : ::quiche::LogStreamVoidHelper() & (stream)
+#define QUICHE_DISREGARD_LOG_STREAM(stream) \
+  QUICHE_CONDITIONAL_LOG_STREAM(stream, /*condition=*/false)
+#define QUICHE_NOOP_STREAM() \
+  QUICHE_DISREGARD_LOG_STREAM(::quiche::NoopLogSink().stream())
+#define QUICHE_NOOP_STREAM_WITH_CONDITION(condition) \
+  QUICHE_DISREGARD_LOG_STREAM(::quiche::NoopLogSink(condition).stream())
+
+#define QUICHE_DVLOG_IMPL(verbose_level) QUICHE_NOOP_STREAM()
 #define QUICHE_DVLOG_IF_IMPL(verbose_level, condition) \
-  ::quiche::NoopLogSink(#verbose_level, condition).stream()
-#define QUICHE_DLOG_IMPL(severity) ::quiche::NoopLogSink(#severity).stream()
-#define QUICHE_DLOG_IF_IMPL(severity, condition) \
-  ::quiche::NoopLogSink(#severity, condition).stream()
-#define QUICHE_VLOG_IMPL(verbose_level) \
-  ::quiche::NoopLogSink(#verbose_level).stream()
-#define QUICHE_LOG_FIRST_N_IMPL(severity, n) \
-  ::quiche::NoopLogSink(#severity, n).stream()
-#define QUICHE_LOG_EVERY_N_SEC_IMPL(severity, seconds) \
-  ::quiche::NoopLogSink(#severity, seconds).stream()
-#define QUICHE_LOG_IF_IMPL(severity, condition) \
-  ::quiche::NoopLogSink(#severity, condition).stream()
+  QUICHE_NOOP_STREAM_WITH_CONDITION(condition)
+#define QUICHE_DLOG_IMPL(severity) QUICHE_NOOP_STREAM()
+#define QUICHE_VLOG_IMPL(verbose_level) QUICHE_NOOP_STREAM()
+#define QUICHE_LOG_FIRST_N_IMPL(severity, n) QUICHE_NOOP_STREAM()
+#define QUICHE_LOG_EVERY_N_SEC_IMPL(severity, seconds) QUICHE_NOOP_STREAM()
 
 #define QUICHE_LOG_IMPL(severity) QUICHE_LOG_IMPL_##severity()
 #define QUICHE_LOG_IMPL_FATAL() ::quiche::FatalLogSink().stream()
-#define QUICHE_LOG_IMPL_DFATAL() ::quiche::NoopLogSink().stream()
 #define QUICHE_LOG_IMPL_ERROR() ::quiche::NoopLogSink().stream()
 #define QUICHE_LOG_IMPL_WARNING() ::quiche::NoopLogSink().stream()
 #define QUICHE_LOG_IMPL_INFO() ::quiche::NoopLogSink().stream()
 
-#define QUICHE_PREDICT_FALSE_IMPL(x) (x)
-#define QUICHE_PREDICT_TRUE_IMPL(x) (x)
+#define QUICHE_LOG_IF_IMPL(severity, condition) \
+  QUICHE_CONDITIONAL_LOG_STREAM(QUICHE_LOG_IMPL_##severity(), condition)
 
-#define QUICHE_PLOG_IMPL(severity) ::quiche::NoopLogSink(#severity)
+#ifdef NDEBUG
+#define QUICHE_LOG_IMPL_DFATAL() ::quiche::NoopLogSink().stream()
+#define QUICHE_DLOG_IF_IMPL(severity, condition) \
+  QUICHE_NOOP_STREAM_WITH_CONDITION(condition)
+#else
+#define QUICHE_LOG_IMPL_DFATAL() ::quiche::FatalLogSink().stream()
+#define QUICHE_DLOG_IF_IMPL(severity, condition) \
+  QUICHE_CONDITIONAL_LOG_STREAM(QUICHE_LOG_IMPL_##severity(), condition)
+#endif
+
+#define QUICHE_PLOG_IMPL(severity) QUICHE_NOOP_STREAM()
 
 #define QUICHE_DLOG_INFO_IS_ON_IMPL() false
 #define QUICHE_LOG_INFO_IS_ON_IMPL() false
 #define QUICHE_LOG_WARNING_IS_ON_IMPL() false
 #define QUICHE_LOG_ERROR_IS_ON_IMPL() false
 
-// This is necessary because we sometimes call QUICHE_DCHECK inside constexpr
-// functions, and then write non-constexpr expressions into the resulting log.
-#define QUICHE_DISREGARD_LOG_STREAM(stream) \
-  true ? (void)0 : ::quiche::NoopLogSink() & (stream)
-
-#define QUICHE_CHECK_IMPL(condition) ::quiche::NoopLogSink(condition).stream()
+#define QUICHE_CHECK_IMPL(condition) \
+  ::quiche::CheckLogSink(static_cast<bool>(condition)).stream()
 #define QUICHE_CHECK_EQ_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
+  ::quiche::CheckLogSink((val1) == (val2)).stream()
 #define QUICHE_CHECK_NE_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
+  ::quiche::CheckLogSink((val1) != (val2)).stream()
 #define QUICHE_CHECK_LE_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
+  ::quiche::CheckLogSink((val1) <= (val2)).stream()
 #define QUICHE_CHECK_LT_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
+  ::quiche::CheckLogSink((val1) < (val2)).stream()
 #define QUICHE_CHECK_GE_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
+  ::quiche::CheckLogSink((val1) >= (val2)).stream()
 #define QUICHE_CHECK_GT_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
+  ::quiche::CheckLogSink((val1) > (val2)).stream()
 
+#ifdef NDEBUG
 #define QUICHE_DCHECK_IMPL(condition) \
-  QUICHE_DISREGARD_LOG_STREAM(::quiche::NoopLogSink(condition).stream())
-#define QUICHE_DCHECK_EQ_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
-#define QUICHE_DCHECK_NE_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
-#define QUICHE_DCHECK_LE_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
-#define QUICHE_DCHECK_LT_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
-#define QUICHE_DCHECK_GE_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
-#define QUICHE_DCHECK_GT_IMPL(val1, val2) \
-  ::quiche::NoopLogSink(val1, val2).stream()
+  QUICHE_NOOP_STREAM_WITH_CONDITION((condition))
+#else
+#define QUICHE_DCHECK_IMPL(condition) \
+  QUICHE_LOG_IF_IMPL(DFATAL, !static_cast<bool>(condition))
+#endif
+#define QUICHE_DCHECK_EQ_IMPL(val1, val2) QUICHE_DCHECK_IMPL((val1) == (val2))
+#define QUICHE_DCHECK_NE_IMPL(val1, val2) QUICHE_DCHECK_IMPL((val1) != (val2))
+#define QUICHE_DCHECK_LE_IMPL(val1, val2) QUICHE_DCHECK_IMPL((val1) <= (val2))
+#define QUICHE_DCHECK_LT_IMPL(val1, val2) QUICHE_DCHECK_IMPL((val1) < (val2))
+#define QUICHE_DCHECK_GE_IMPL(val1, val2) QUICHE_DCHECK_IMPL((val1) >= (val2))
+#define QUICHE_DCHECK_GT_IMPL(val1, val2) QUICHE_DCHECK_IMPL((val1) > (val2))
 
 #define QUICHE_NOTREACHED_IMPL() QUICHE_DCHECK_IMPL(false)
 

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_lower_case_string_impl.h

@@ -0,0 +1,25 @@
+#ifndef QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_LOWER_CASE_STRING_IMPL_H_
+#define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_LOWER_CASE_STRING_IMPL_H_
+
+#include <string>
+
+#include "absl/strings/ascii.h"
+#include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace quiche {
+
+class QUICHE_EXPORT_PRIVATE QuicheLowerCaseStringImpl {
+ public:
+  QuicheLowerCaseStringImpl(absl::string_view str)
+      : str_(absl::AsciiStrToLower(str)) {}
+
+  const std::string& get() const { return str_; }
+
+ private:
+  std::string str_;
+};
+
+}  // namespace quiche
+
+#endif  // QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_LOWER_CASE_STRING_IMPL_H_

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_stack_trace_impl.cc

@@ -23,7 +23,7 @@ constexpr absl::string_view kUnknownSymbol = "(unknown)";
 std::string QuicheStackTraceImpl() {
   std::vector<void*> stacktrace(kMaxStackSize, nullptr);
   int num_frames = absl::GetStackTrace(stacktrace.data(), stacktrace.size(),
-                                       /*skip_count=*/1);
+                                       /*skip_count=*/0);
   if (num_frames <= 0) {
     return "";
   }

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_test_impl.cc

@@ -0,0 +1,25 @@
+// 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.
+
+#include "quiche_platform_impl/quiche_test_impl.h"
+
+#include "quiche/common/platform/api/quiche_flags.h"
+
+QuicheFlagSaverImpl::QuicheFlagSaverImpl() {
+#define QUIC_FLAG(flag, value) saved_##flag##_ = flag;
+#include "quiche/quic/core/quic_flags_list.h"
+#undef QUIC_FLAG
+#define QUIC_PROTOCOL_FLAG(type, flag, ...) saved_##flag##_ = FLAGS_##flag;
+#include "quiche/quic/core/quic_protocol_flags_list.h"
+#undef QUIC_PROTOCOL_FLAG
+}
+
+QuicheFlagSaverImpl::~QuicheFlagSaverImpl() {
+#define QUIC_FLAG(flag, value) flag = saved_##flag##_;
+#include "quiche/quic/core/quic_flags_list.h"  // NOLINT
+#undef QUIC_FLAG
+#define QUIC_PROTOCOL_FLAG(type, flag, ...) FLAGS_##flag = saved_##flag##_;
+#include "quiche/quic/core/quic_protocol_flags_list.h"  // NOLINT
+#undef QUIC_PROTOCOL_FLAG
+}

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_test_impl.h

@@ -0,0 +1,56 @@
+// 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_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_TEST_IMPL_H_
+#define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_TEST_IMPL_H_
+
+#include "gmock/gmock.h"
+#include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
+
+#define EXPECT_QUICHE_DEBUG_DEATH_IMPL(condition, message) \
+  EXPECT_DEBUG_DEATH(condition, message)
+
+#define QUICHE_TEST_DISABLED_IN_CHROME_IMPL(name) name
+#define QUICHE_SLOW_TEST_IMPL(test) test
+
+class QuicheFlagSaverImpl {
+ public:
+  QuicheFlagSaverImpl();
+  ~QuicheFlagSaverImpl();
+
+ private:
+#define QUIC_FLAG(flag, value) bool saved_##flag##_;
+#include "quiche/quic/core/quic_flags_list.h"
+#undef QUIC_FLAG
+
+#define QUIC_PROTOCOL_FLAG(type, flag, ...) type saved_##flag##_;
+#include "quiche/quic/core/quic_protocol_flags_list.h"
+#undef QUIC_PROTOCOL_FLAG
+};
+
+class ScopedEnvironmentForThreadsImpl {};
+
+namespace quiche::test {
+
+class QuicheTestImpl : public ::testing::Test {
+ private:
+  QuicheFlagSaverImpl saver_;
+};
+
+template <class T>
+class QuicheTestWithParamImpl : public ::testing::TestWithParam<T> {
+ private:
+  QuicheFlagSaverImpl saver_;
+};
+
+inline std::string QuicheGetCommonSourcePathImpl() { return "quiche/common"; }
+
+}  // namespace quiche::test
+
+inline std::string QuicheGetTestMemoryCachePathImpl() {
+  return "quiche/quic/test_tools/quic_http_response_cache_data";
+}
+
+#endif  // QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_TEST_IMPL_H_

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_test_output_impl.h

@@ -0,0 +1,27 @@
+// Copyright (c) 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_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_TEST_OUTPUT_IMPL_H_
+#define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_TEST_OUTPUT_IMPL_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+
+namespace quiche {
+
+inline void QuicheSaveTestOutputImpl(absl::string_view /*filename*/,
+                                     absl::string_view /*data*/) {}
+
+inline bool QuicheLoadTestOutputImpl(absl::string_view /*filename*/,
+                                     std::string* /*data*/) {
+  return false;
+}
+
+inline void QuicheRecordTraceImpl(absl::string_view /*identifier*/,
+                                  absl::string_view /*data*/) {}
+
+}  // namespace quiche
+
+#endif  // QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_TEST_OUTPUT_IMPL_H_

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_thread_impl.h

@@ -0,0 +1,26 @@
+#ifndef QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_THREAD_IMPL_H_
+#define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_THREAD_IMPL_H_
+
+#include <string>
+#include <thread>  // NOLINT: only used outside of google3
+
+#include "absl/types/optional.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+class QUICHE_NO_EXPORT QuicheThreadImpl {
+ public:
+  QuicheThreadImpl(const std::string&) {}
+  virtual ~QuicheThreadImpl() {}
+
+  virtual void Run() = 0;
+
+  void Start() {
+    thread_.emplace([this]() { Run(); });
+  }
+  void Join() { thread_->join(); }
+
+ private:
+  absl::optional<std::thread> thread_;
+};
+
+#endif  // QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_THREAD_IMPL_H_

package/third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_url_utils_impl.cc

@@ -62,6 +62,7 @@ absl::optional<std::string> AsciiUrlDecodeImpl(absl::string_view input) {
   std::string input_encoded = std::string(input);
   url::RawCanonOutputW<1024> canon_output;
   url::DecodeURLEscapeSequences(input_encoded.c_str(), input_encoded.length(),
+                                url::DecodeURLMode::kUTF8,
                                 &canon_output);
   std::string output;
   output.reserve(canon_output.length());

package/third_party/quiche/quiche/common/quiche_buffer_allocator_test.cc

@@ -5,8 +5,8 @@
 #include "quiche/common/quiche_buffer_allocator.h"
 
 #include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 #include "quiche/common/simple_buffer_allocator.h"
 #include "quiche/common/test_tools/quiche_test_utils.h"
 

package/third_party/quiche/quiche/common/quiche_mem_slice_storage.h

@@ -24,9 +24,8 @@ class QUICHE_EXPORT_PRIVATE QuicheMemSliceStorage {
                         QuicheBufferAllocator* allocator,
                         const quic::QuicByteCount max_slice_len);
 
-  QuicheMemSliceStorage(const QuicheMemSliceStorage& other) = default;
-  QuicheMemSliceStorage& operator=(const QuicheMemSliceStorage& other) =
-      default;
+  QuicheMemSliceStorage(const QuicheMemSliceStorage& other) = delete;
+  QuicheMemSliceStorage& operator=(const QuicheMemSliceStorage& other) = delete;
   QuicheMemSliceStorage(QuicheMemSliceStorage&& other) = default;
   QuicheMemSliceStorage& operator=(QuicheMemSliceStorage&& other) = default;
 

package/third_party/quiche/quiche/common/structured_headers.cc

@@ -147,7 +147,7 @@ class StructuredHeaderParser {
   // for parsing an Item from [SH09] 4.2.7).
   absl::optional<Item> ReadBareItem() {
     if (input_.empty()) {
-      DVLOG(1) << "ReadBareItem: unexpected EOF";
+      QUICHE_DVLOG(1) << "ReadBareItem: unexpected EOF";
       return absl::nullopt;
     }
     switch (input_.front()) {
@@ -234,8 +234,8 @@ class StructuredHeaderParser {
         value = std::move(*item);
       }
       if (!parameters.emplace(*name, value).second) {
-        DVLOG(1) << "ReadParameterisedIdentifier: duplicated parameter: "
-                 << *name;
+        QUICHE_DVLOG(1) << "ReadParameterisedIdentifier: duplicated parameter: "
+                        << *name;
         return absl::nullopt;
       }
       SkipWhitespaces();
@@ -426,24 +426,24 @@ class StructuredHeaderParser {
       size_t i = 0;
       for (; i < input_.size(); ++i) {
         if (!absl::ascii_isprint(input_[i])) {
-          DVLOG(1) << "ReadString: non printable-ASCII character";
+          QUICHE_DVLOG(1) << "ReadString: non printable-ASCII character";
           return absl::nullopt;
         }
         if (input_[i] == '"' || input_[i] == '\\') break;
       }
       if (i == input_.size()) {
-        DVLOG(1) << "ReadString: missing closing '\"'";
+        QUICHE_DVLOG(1) << "ReadString: missing closing '\"'";
         return absl::nullopt;
       }
       s.append(std::string(input_.substr(0, i)));
       input_.remove_prefix(i);
       if (ConsumeChar('\\')) {
         if (input_.empty()) {
-          DVLOG(1) << "ReadString: backslash at string end";
+          QUICHE_DVLOG(1) << "ReadString: backslash at string end";
           return absl::nullopt;
         }
         if (input_[0] != '"' && input_[0] != '\\') {
-          DVLOG(1) << "ReadString: invalid escape";
+          QUICHE_DVLOG(1) << "ReadString: invalid escape";
           return absl::nullopt;
         }
         s.push_back(input_.front());
@@ -462,7 +462,7 @@ class StructuredHeaderParser {
     }
     size_t len = input_.find(delimiter);
     if (len == absl::string_view::npos) {
-      DVLOG(1) << "ReadByteSequence: missing closing delimiter";
+      QUICHE_DVLOG(1) << "ReadByteSequence: missing closing delimiter";
       return absl::nullopt;
     }
     std::string base64(input_.substr(0, len));
@@ -471,7 +471,8 @@ class StructuredHeaderParser {
 
     std::string binary;
     if (!absl::Base64Unescape(base64, &binary)) {
-      DVLOG(1) << "ReadByteSequence: failed to decode base64: " << base64;
+      QUICHE_DVLOG(1) << "ReadByteSequence: failed to decode base64: "
+                      << base64;
       return absl::nullopt;
     }
     input_.remove_prefix(len);
@@ -518,9 +519,10 @@ class StructuredHeaderParser {
   }
 
   void LogParseError(const char* func, const char* expected) {
-    DVLOG(1) << func << ": " << expected << " expected, got "
-             << (input_.empty() ? "EOS"
-                                : "'" + std::string(input_.substr(0, 1)) + "'");
+    QUICHE_DVLOG(1) << func << ": " << expected << " expected, got "
+                    << (input_.empty()
+                            ? "EOS"
+                            : "'" + std::string(input_.substr(0, 1)) + "'");
   }
 
   absl::string_view input_;

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

@@ -116,12 +116,13 @@ bool EventForwarder::OnGoAwayFrameData(const char* goaway_data, size_t len) {
   return false;
 }
 
-void EventForwarder::OnHeaders(spdy::SpdyStreamId stream_id, bool has_priority,
+void EventForwarder::OnHeaders(spdy::SpdyStreamId stream_id,
+                               size_t payload_length, bool has_priority,
                                int weight, spdy::SpdyStreamId parent_stream_id,
                                bool exclusive, bool fin, bool end) {
   if (can_forward_()) {
-    receiver_.OnHeaders(stream_id, has_priority, weight, parent_stream_id,
-                        exclusive, fin, end);
+    receiver_.OnHeaders(stream_id, payload_length, has_priority, weight,
+                        parent_stream_id, exclusive, fin, end);
   }
 }
 
@@ -140,9 +141,10 @@ void EventForwarder::OnPushPromise(spdy::SpdyStreamId stream_id,
   }
 }
 
-void EventForwarder::OnContinuation(spdy::SpdyStreamId stream_id, bool end) {
+void EventForwarder::OnContinuation(spdy::SpdyStreamId stream_id,
+                                    size_t payload_length, bool end) {
   if (can_forward_()) {
-    receiver_.OnContinuation(stream_id, end);
+    receiver_.OnContinuation(stream_id, payload_length, end);
   }
 }
 

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

@@ -46,14 +46,16 @@ class QUICHE_EXPORT_PRIVATE EventForwarder
   void OnGoAway(spdy::SpdyStreamId last_accepted_stream_id,
                 spdy::SpdyErrorCode error_code) override;
   bool OnGoAwayFrameData(const char* goaway_data, size_t len) override;
-  void OnHeaders(spdy::SpdyStreamId stream_id, bool has_priority, int weight,
+  void OnHeaders(spdy::SpdyStreamId stream_id, size_t payload_length,
+                 bool has_priority, int weight,
                  spdy::SpdyStreamId parent_stream_id, bool exclusive, bool fin,
                  bool end) override;
   void OnWindowUpdate(spdy::SpdyStreamId stream_id,
                       int delta_window_size) override;
   void OnPushPromise(spdy::SpdyStreamId stream_id,
                      spdy::SpdyStreamId promised_stream_id, bool end) override;
-  void OnContinuation(spdy::SpdyStreamId stream_id, bool end) override;
+  void OnContinuation(spdy::SpdyStreamId stream_id, size_t payload_length,
+                      bool end) override;
   void OnAltSvc(spdy::SpdyStreamId stream_id, absl::string_view origin,
                 const spdy::SpdyAltSvcWireFormat::AlternativeServiceVector&
                     altsvc_vector) override;