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

package/third_party/quiche/quiche/{common/balsa → balsa}/header_properties_test.cc

@@ -1,4 +1,4 @@
-#include "quiche/common/balsa/header_properties.h"
+#include "quiche/balsa/header_properties.h"
 
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/{common/balsa → balsa}/http_validation_policy.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/common/balsa/http_validation_policy.h"
+#include "quiche/balsa/http_validation_policy.h"
 
 #include <tuple>
 

package/third_party/quiche/quiche/{common/balsa → balsa}/http_validation_policy.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_COMMON_BALSA_HTTP_VALIDATION_POLICY_H_
-#define QUICHE_COMMON_BALSA_HTTP_VALIDATION_POLICY_H_
+#ifndef QUICHE_BALSA_HTTP_VALIDATION_POLICY_H_
+#define QUICHE_BALSA_HTTP_VALIDATION_POLICY_H_
 
 #include <ostream>
 
@@ -52,4 +52,4 @@ class QUICHE_EXPORT_PRIVATE HttpValidationPolicy {
 
 }  // namespace quiche
 
-#endif  // QUICHE_COMMON_BALSA_HTTP_VALIDATION_POLICY_H_
+#endif  // QUICHE_BALSA_HTTP_VALIDATION_POLICY_H_

package/third_party/quiche/quiche/{common/balsa → balsa}/noop_balsa_visitor.h

@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef QUICHE_COMMON_BALSA_NOOP_BALSA_VISITOR_H_
-#define QUICHE_COMMON_BALSA_NOOP_BALSA_VISITOR_H_
+#ifndef QUICHE_BALSA_NOOP_BALSA_VISITOR_H_
+#define QUICHE_BALSA_NOOP_BALSA_VISITOR_H_
 
 #include <cstddef>
 
 #include "absl/strings/string_view.h"
-#include "quiche/common/balsa/balsa_visitor_interface.h"
+#include "quiche/balsa/balsa_visitor_interface.h"
 #include "quiche/common/platform/api/quiche_export.h"
 
 namespace quiche {
@@ -53,4 +53,4 @@ class QUICHE_EXPORT_PRIVATE NoOpBalsaVisitor : public BalsaVisitorInterface {
 
 }  // namespace quiche
 
-#endif  // QUICHE_COMMON_BALSA_NOOP_BALSA_VISITOR_H_
+#endif  // QUICHE_BALSA_NOOP_BALSA_VISITOR_H_

package/third_party/quiche/quiche/{common/balsa → balsa}/simple_buffer.cc

@@ -2,8 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/common/balsa/simple_buffer.h"
+#include "quiche/balsa/simple_buffer.h"
 
+#include <algorithm>
 #include <cstring>
 #include <memory>
 
@@ -12,35 +13,20 @@
 
 namespace quiche {
 
-static const int kInitialSimpleBufferSize = 10;
+constexpr int kMinimumSimpleBufferSize = 10;
 
-SimpleBuffer::SimpleBuffer()
-    : storage_(new char[kInitialSimpleBufferSize]),
-      write_idx_(0),
-      read_idx_(0),
-      storage_size_(kInitialSimpleBufferSize) {}
-
-SimpleBuffer::SimpleBuffer(int size)
-    : write_idx_(0), read_idx_(0), storage_size_(size) {
-  // Callers may try to allocate overly large blocks, but negative sizes are
-  // obviously wrong.
-  QUICHE_CHECK_GE(size, 0);
-  storage_ = new char[size];
-}
+SimpleBuffer::SimpleBuffer(int size) { Reserve(size); }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 int SimpleBuffer::Write(const char* bytes, int size) {
-  if (size < 0) {
-    QUICHE_BUG(simple_buffer_write_negative_size)
+  if (size <= 0) {
+    QUICHE_BUG_IF(simple_buffer_write_negative_size, size < 0)
         << "size must not be negative: " << size;
     return 0;
   }
 
-  bool has_room = ((storage_size_ - write_idx_) >= size);
-  if (!has_room) {
-    Reserve(size);
-  }
+  Reserve(size);
   memcpy(storage_ + write_idx_, bytes, size);
   AdvanceWritablePtr(size);
   return size;
@@ -58,9 +44,11 @@ int SimpleBuffer::Read(char* bytes, int size) {
   char* read_ptr = nullptr;
   int read_size = 0;
   GetReadablePtr(&read_ptr, &read_size);
-  if (read_size > size) {
-    read_size = size;
+  read_size = std::min(read_size, size);
+  if (read_size == 0) {
+    return 0;
   }
+
   memcpy(bytes, read_ptr, read_size);
   AdvanceReadablePtr(read_size);
   return read_size;
@@ -85,6 +73,15 @@ void SimpleBuffer::Reserve(int size) {
   int read_size = 0;
   GetReadablePtr(&read_ptr, &read_size);
 
+  if (read_ptr == nullptr) {
+    QUICHE_DCHECK_EQ(0, read_size);
+
+    size = std::max(size, kMinimumSimpleBufferSize);
+    storage_ = new char[size];
+    storage_size_ = size;
+    return;
+  }
+
   if (read_size + size <= storage_size_) {
     // Can reclaim space from consumed bytes by shifting.
     memmove(storage_, read_ptr, read_size);
@@ -95,19 +92,15 @@ void SimpleBuffer::Reserve(int size) {
 
   // The new buffer needs to be at least `read_size + size` bytes.
   // At least double the buffer to amortize allocation costs.
-  int new_storage_size = 2 * storage_size_;
-  if (new_storage_size < size + read_size) {
-    new_storage_size = size + read_size;
-  }
+  storage_size_ = std::max(2 * storage_size_, size + read_size);
 
-  char* new_storage = new char[new_storage_size];
+  char* new_storage = new char[storage_size_];
   memcpy(new_storage, read_ptr, read_size);
   delete[] storage_;
 
   read_idx_ = 0;
   write_idx_ = read_size;
   storage_ = new_storage;
-  storage_size_ = new_storage_size;
 }
 
 void SimpleBuffer::AdvanceReadablePtr(int amount_to_advance) {

package/third_party/quiche/quiche/{common/balsa → balsa}/simple_buffer.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_COMMON_BALSA_SIMPLE_BUFFER_H_
-#define QUICHE_COMMON_BALSA_SIMPLE_BUFFER_H_
+#ifndef QUICHE_BALSA_SIMPLE_BUFFER_H_
+#define QUICHE_BALSA_SIMPLE_BUFFER_H_
 
 #include "absl/strings/string_view.h"
 #include "quiche/common/platform/api/quiche_export.h"
@@ -20,8 +20,8 @@ class SimpleBufferTest;
 // position.  Reading consumes data.
 class QUICHE_EXPORT_PRIVATE SimpleBuffer {
  public:
-  SimpleBuffer();
-  // Create SimpleBuffer with `size` reserved capacity.
+  SimpleBuffer() = default;
+  // Create SimpleBuffer with at least `size` reserved capacity.
   explicit SimpleBuffer(int size);
 
   SimpleBuffer(const SimpleBuffer&) = delete;
@@ -40,18 +40,19 @@ class QUICHE_EXPORT_PRIVATE SimpleBuffer {
     return Write(piece.data(), piece.size());
   }
 
-  // Gets a pointer into the buffer that can be written to.  Stores the number
-  // of characters which are allowed to be written in `*size`. The pointer and
-  // size can be used in functions like recv() or read().  If `*size` is zero
-  // upon returning from this function, then it is unsafe to dereference `*ptr`.
-  // Writing to this region after calling any other non-const method results in
-  // undefined behavior.
+  // Stores the pointer into the buffer that can be written to in `*ptr`, and
+  // the number of characters that are allowed to be written in `*size`.  The
+  // pointer and size can be used in functions like recv() or read().  If
+  // `*size` is zero upon returning from this function, then it is unsafe to
+  // dereference `*ptr`.  Writing to this region after calling any other
+  // non-const method results in undefined behavior.
   void GetWritablePtr(char** ptr, int* size) const {
     *ptr = storage_ + write_idx_;
     *size = storage_size_ - write_idx_;
   }
 
-  // Gets a pointer that can be read from.  This pointer (and size) can be used
+  // Stores the pointer that can be read from in `*ptr`, and the number of bytes
+  // that are allowed to be read in `*size`.  The pointer and size can be used
   // in functions like send() or write().  If `*size` is zero upon returning
   // from this function, then it is unsafe to dereference `*ptr`.  Reading from
   // this region after calling any other non-const method results in undefined
@@ -100,17 +101,18 @@ class QUICHE_EXPORT_PRIVATE SimpleBuffer {
 
   // The buffer owned by this class starts at `*storage_` and is `storage_size_`
   // bytes long.
+  // If `storage_` is nullptr, then `storage_size_` must be zero.
   // `0 <= read_idx_ <= write_idx_ <= storage_size_` must always hold.
   // If `read_idx_ == write_idx_`, then they must be equal to zero.
   // The first `read_idx_` bytes of the buffer are consumed,
   // the next `write_idx_ - read_idx_` bytes are the readable region, and the
   // remaining `storage_size_ - write_idx_` bytes are the writable region.
-  char* storage_;
-  int write_idx_;
-  int read_idx_;
-  int storage_size_;
+  char* storage_ = nullptr;
+  int write_idx_ = 0;
+  int read_idx_ = 0;
+  int storage_size_ = 0;
 };
 
 }  // namespace quiche
 
-#endif  // QUICHE_COMMON_BALSA_SIMPLE_BUFFER_H_
+#endif  // QUICHE_BALSA_SIMPLE_BUFFER_H_

package/third_party/quiche/quiche/{common/balsa → balsa}/simple_buffer_test.cc

@@ -2,11 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/common/balsa/simple_buffer.h"
+#include "quiche/balsa/simple_buffer.h"
 
 #include <string>
 
 #include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"
 
 namespace quiche {
@@ -15,6 +16,8 @@ namespace test {
 
 namespace {
 
+constexpr int kMinimumSimpleBufferSize = 10;
+
 // Buffer full of 40 char strings.
 const char ibuf[] = {
     "123456789!@#$%^&*()abcdefghijklmnopqrstu"
@@ -35,31 +38,60 @@ class SimpleBufferTest : public QuicheTest {
 
 namespace {
 
-TEST_F(SimpleBufferTest, TestCreationWithSize) {
-  SimpleBuffer buffer(5);
-  EXPECT_EQ(5, storage_size(buffer));
+TEST_F(SimpleBufferTest, CreationWithSize) {
+  SimpleBuffer buffer1(5);
+  EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer1));
+
+  SimpleBuffer buffer2(25);
+  EXPECT_EQ(25, storage_size(buffer2));
 }
 
 // Make sure that a zero-sized initial buffer does not throw things off.
-TEST_F(SimpleBufferTest, TestCreationWithZeroSize) {
+TEST_F(SimpleBufferTest, CreationWithZeroSize) {
   SimpleBuffer buffer(0);
   EXPECT_EQ(0, storage_size(buffer));
   EXPECT_EQ(4, buffer.Write(ibuf, 4));
   EXPECT_EQ(4, write_idx(buffer));
-  EXPECT_EQ(4, storage_size(buffer));
+  EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(4, buffer.ReadableBytes());
 }
 
-TEST(SimpleBufferDeathTest, TestCreationWithNegativeSize) {
-  EXPECT_DEATH(SimpleBuffer buffer(-1), "Check failed");
+TEST_F(SimpleBufferTest, ReadZeroBytes) {
+  SimpleBuffer buffer;
+
+  EXPECT_EQ(0, buffer.Read(nullptr, 0));
+}
+
+TEST_F(SimpleBufferTest, WriteZeroFromNullptr) {
+  SimpleBuffer buffer;
+
+  EXPECT_EQ(0, buffer.Write(nullptr, 0));
+}
+
+TEST(SimpleBufferExpectBug, ReserveNegativeSize) {
+  SimpleBuffer buffer;
+
+  EXPECT_QUICHE_BUG(buffer.Reserve(-1), "size must not be negative");
+}
+
+TEST(SimpleBufferExpectBug, ReadNegativeSize) {
+  SimpleBuffer buffer;
+
+  EXPECT_QUICHE_BUG(buffer.Read(nullptr, -1), "size must not be negative");
+}
+
+TEST(SimpleBufferExpectBug, WriteNegativeSize) {
+  SimpleBuffer buffer;
+
+  EXPECT_QUICHE_BUG(buffer.Write(nullptr, -1), "size must not be negative");
 }
 
-TEST_F(SimpleBufferTest, TestBasics) {
+TEST_F(SimpleBufferTest, Basics) {
   SimpleBuffer buffer;
 
   EXPECT_TRUE(buffer.Empty());
   EXPECT_EQ("", buffer.GetReadableRegion());
-  EXPECT_EQ(10, storage_size(buffer));
+  EXPECT_EQ(0, storage_size(buffer));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(0, write_idx(buffer));
 
@@ -73,20 +105,20 @@ TEST_F(SimpleBufferTest, TestBasics) {
   EXPECT_EQ(storage(buffer), readable_ptr);
   EXPECT_EQ(0, readable_size);
   EXPECT_EQ(storage(buffer), writeable_ptr);
-  EXPECT_EQ(10, writable_size);
+  EXPECT_EQ(0, writable_size);
   EXPECT_EQ(0, buffer.ReadableBytes());
 
   const SimpleBuffer buffer2;
   EXPECT_EQ(0, buffer2.ReadableBytes());
 }
 
-TEST_F(SimpleBufferTest, TestBasicWR) {
+TEST_F(SimpleBufferTest, BasicWR) {
   SimpleBuffer buffer;
 
   EXPECT_EQ(4, buffer.Write(ibuf, 4));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(4, write_idx(buffer));
-  EXPECT_EQ(10, storage_size(buffer));
+  EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(4, buffer.ReadableBytes());
   EXPECT_EQ("1234", buffer.GetReadableRegion());
   int bytes_written = 4;
@@ -109,7 +141,7 @@ TEST_F(SimpleBufferTest, TestBasicWR) {
   EXPECT_EQ(4, buffer.Read(obuf + bytes_read, 40));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(0, write_idx(buffer));
-  EXPECT_EQ(10, storage_size(buffer));
+  EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(0, buffer.ReadableBytes());
   EXPECT_EQ("", buffer.GetReadableRegion());
   bytes_read += 4;
@@ -119,7 +151,7 @@ TEST_F(SimpleBufferTest, TestBasicWR) {
   EXPECT_EQ(storage(buffer), readable_ptr);
   EXPECT_EQ(0, readable_size);
   EXPECT_EQ(storage(buffer), writeable_ptr);
-  EXPECT_EQ(10, writable_size);
+  EXPECT_EQ(kMinimumSimpleBufferSize, writable_size);
 
   EXPECT_EQ(bytes_written, bytes_read);
   for (int i = 0; i < bytes_read; ++i) {
@@ -160,37 +192,41 @@ TEST_F(SimpleBufferTest, TestBasicWR) {
   }
 }
 
-TEST_F(SimpleBufferTest, TestReserve) {
+TEST_F(SimpleBufferTest, Reserve) {
   SimpleBuffer buffer;
+  EXPECT_EQ(0, storage_size(buffer));
+
+  buffer.WriteString("foo");
+  EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
 
   // Reserve by expanding the buffer.
-  const int initial_size = storage_size(buffer);
-  buffer.Reserve(initial_size + 1);
-  EXPECT_EQ(2 * initial_size, storage_size(buffer));
+  buffer.Reserve(kMinimumSimpleBufferSize + 1);
+  EXPECT_EQ(2 * kMinimumSimpleBufferSize, storage_size(buffer));
 
-  buffer.AdvanceWritablePtr(initial_size);
-  buffer.AdvanceReadablePtr(initial_size - 2);
-  EXPECT_EQ(initial_size, write_idx(buffer));
-  EXPECT_EQ(2 * initial_size, storage_size(buffer));
+  buffer.Clear();
+  buffer.AdvanceWritablePtr(kMinimumSimpleBufferSize);
+  buffer.AdvanceReadablePtr(kMinimumSimpleBufferSize - 2);
+  EXPECT_EQ(kMinimumSimpleBufferSize, write_idx(buffer));
+  EXPECT_EQ(2 * kMinimumSimpleBufferSize, storage_size(buffer));
 
   // Reserve by moving data around.  `storage_size` does not change.
-  buffer.Reserve(initial_size + 1);
+  buffer.Reserve(kMinimumSimpleBufferSize + 1);
   EXPECT_EQ(2, write_idx(buffer));
-  EXPECT_EQ(2 * initial_size, storage_size(buffer));
+  EXPECT_EQ(2 * kMinimumSimpleBufferSize, storage_size(buffer));
 }
 
-TEST_F(SimpleBufferTest, TestExtend) {
+TEST_F(SimpleBufferTest, Extend) {
   SimpleBuffer buffer;
 
   // Test a write which should not extend the buffer.
   EXPECT_EQ(7, buffer.Write(ibuf, 7));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(7, write_idx(buffer));
-  EXPECT_EQ(10, storage_size(buffer));
+  EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(7, buffer.ReadableBytes());
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(7, write_idx(buffer));
-  EXPECT_EQ(10, storage_size(buffer));
+  EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(7, buffer.ReadableBytes());
   int bytes_written = 7;
 
@@ -218,18 +254,26 @@ TEST_F(SimpleBufferTest, TestExtend) {
   }
 }
 
-TEST_F(SimpleBufferTest, TestClear) {
+TEST_F(SimpleBufferTest, Clear) {
   SimpleBuffer buffer;
 
   buffer.Clear();
+
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(0, write_idx(buffer));
-  EXPECT_EQ(10, storage_size(buffer));
+  EXPECT_EQ(0, storage_size(buffer));
+  EXPECT_EQ(0, buffer.ReadableBytes());
+
+  buffer.WriteString("foo");
+  buffer.Clear();
+
+  EXPECT_EQ(0, read_idx(buffer));
+  EXPECT_EQ(0, write_idx(buffer));
+  EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(0, buffer.ReadableBytes());
-  EXPECT_EQ(10, storage_size(buffer));
 }
 
-TEST_F(SimpleBufferTest, TestLongWrite) {
+TEST_F(SimpleBufferTest, LongWrite) {
   SimpleBuffer buffer;
 
   std::string s1 = "HTTP/1.1 500 Service Unavailable";
@@ -337,11 +381,13 @@ TEST_F(SimpleBufferTest, ReleaseAsSlice) {
   char* readable_ptr = nullptr;
   int readable_size = 0;
   buffer.GetReadablePtr(&readable_ptr, &readable_size);
+  EXPECT_EQ(nullptr, readable_ptr);
   EXPECT_EQ(0, readable_size);
 
   buffer.WriteString("def");
   slice = buffer.ReleaseAsSlice();
   buffer.GetReadablePtr(&readable_ptr, &readable_size);
+  EXPECT_EQ(nullptr, readable_ptr);
   EXPECT_EQ(0, readable_size);
   EXPECT_EQ("def", slice.AsStringView());
 }
@@ -353,6 +399,7 @@ TEST_F(SimpleBufferTest, EmptyBufferReleaseAsSlice) {
 
   QuicheMemSlice slice = buffer.ReleaseAsSlice();
   buffer.GetReadablePtr(&readable_ptr, &readable_size);
+  EXPECT_EQ(nullptr, readable_ptr);
   EXPECT_EQ(0, readable_size);
   EXPECT_TRUE(slice.empty());
 }

package/third_party/quiche/quiche/{common/balsa → balsa}/standard_header_map.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/common/balsa/standard_header_map.h"
+#include "quiche/balsa/standard_header_map.h"
 
 namespace quiche {
 

package/third_party/quiche/quiche/{common/balsa → balsa}/standard_header_map.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_COMMON_BALSA_STANDARD_HEADER_MAP_H_
-#define QUICHE_COMMON_BALSA_STANDARD_HEADER_MAP_H_
+#ifndef QUICHE_BALSA_STANDARD_HEADER_MAP_H_
+#define QUICHE_BALSA_STANDARD_HEADER_MAP_H_
 
 #include "absl/container/flat_hash_set.h"
 #include "absl/strings/string_view.h"
@@ -21,4 +21,4 @@ const StandardHttpHeaderNameSet& GetStandardHeaderSet();
 
 }  // namespace quiche
 
-#endif  // QUICHE_COMMON_BALSA_STANDARD_HEADER_MAP_H_
+#endif  // QUICHE_BALSA_STANDARD_HEADER_MAP_H_

package/third_party/quiche/quiche/common/platform/api/quiche_command_line_flags.h

@@ -11,12 +11,17 @@
 #include "quiche_platform_impl/quiche_command_line_flags_impl.h"
 
 // Define a command-line flag that can be automatically set via
-// QuicheParseCommandLineFlags().
+// QuicheParseCommandLineFlags().  The macro has to be called in the .cc file of
+// a unit test or the CLI tool reading the flag.
 #define DEFINE_QUICHE_COMMAND_LINE_FLAG(type, name, default_value, help) \
   DEFINE_QUICHE_COMMAND_LINE_FLAG_IMPL(type, name, default_value, help)
 
 namespace quiche {
 
+// The impl header must provide GetQuicheCommandLineFlag(), which takes
+// PlatformSpecificFlag<T> variable defined by the macro above, and returns the
+// flag value of type T.
+
 // Parses command-line flags, setting flag variables defined using
 // DEFINE_QUICHE_COMMAND_LINE_FLAG if they appear in the command line, and
 // returning a list of any non-flag arguments specified in the command line. If

package/third_party/quiche/quiche/common/platform/api/quiche_flags.h

@@ -5,8 +5,12 @@
 #ifndef QUICHE_COMMON_PLATFORM_API_QUICHE_FLAGS_H_
 #define QUICHE_COMMON_PLATFORM_API_QUICHE_FLAGS_H_
 
+#include "quiche_platform_impl/quic_flags_impl.h"
 #include "quiche_platform_impl/quiche_flags_impl.h"
 
+// Flags accessed via GetQuicheReloadableFlag/GetQuicheRestartFlag are temporary
+// boolean flags that are used to enable or disable code behavior changes.  The
+// current list is available in the quiche/quic/core/quic_flags_list.h file.
 #define GetQuicheReloadableFlag(module, flag) \
   GetQuicheReloadableFlagImpl(module, flag)
 #define SetQuicheReloadableFlag(module, flag, value) \
@@ -15,6 +19,10 @@
   GetQuicheRestartFlagImpl(module, flag)
 #define SetQuicheRestartFlag(module, flag, value) \
   SetQuicheRestartFlagImpl(module, flag, value)
+
+// Flags accessed via GetQuicheFlag are permanent flags used to control QUICHE
+// library behavior.  The current list is available in the
+// quiche/quic/core/quic_protocol_flags_list.h file.
 #define GetQuicheFlag(flag) GetQuicheFlagImpl(flag)
 #define SetQuicheFlag(flag, value) SetQuicheFlagImpl(flag, value)
 

package/third_party/quiche/quiche/common/platform/api/quiche_logging.h

@@ -26,9 +26,6 @@
 #define QUICHE_LOG_IF(severity, condition) \
   QUICHE_LOG_IF_IMPL(severity, condition)
 
-#define QUICHE_PREDICT_FALSE(x) QUICHE_PREDICT_FALSE_IMPL(x)
-#define QUICHE_PREDICT_TRUE(x) QUICHE_PREDICT_TRUE_IMPL(x)
-
 // This is a noop in release build.
 #define QUICHE_NOTREACHED() QUICHE_NOTREACHED_IMPL()
 

package/third_party/quiche/quiche/common/platform/api/quiche_lower_case_string_test.cc

@@ -0,0 +1,29 @@
+// 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/common/platform/api/quiche_lower_case_string.h"
+
+#include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_test.h"
+
+namespace quiche::test {
+namespace {
+
+TEST(QuicheLowerCaseString, Basic) {
+  QuicheLowerCaseString empty("");
+  EXPECT_EQ("", empty.get());
+
+  QuicheLowerCaseString from_lower_case("foo");
+  EXPECT_EQ("foo", from_lower_case.get());
+
+  QuicheLowerCaseString from_mixed_case("BaR");
+  EXPECT_EQ("bar", from_mixed_case.get());
+
+  const absl::string_view kData = "FooBar";
+  QuicheLowerCaseString from_string_view(kData);
+  EXPECT_EQ("foobar", from_string_view.get());
+}
+
+}  // namespace
+}  // namespace quiche::test

package/third_party/quiche/quiche/common/platform/api/quiche_test.h

@@ -7,10 +7,12 @@
 
 #include "quiche_platform_impl/quiche_test_impl.h"
 
-using QuicheTest = quiche::test::QuicheTestImpl;
+namespace quiche::test {
+
+using QuicheTest = QuicheTestImpl;
 
 template <class T>
-using QuicheTestWithParam = quiche::test::QuicheTestWithParamImpl<T>;
+using QuicheTestWithParam = QuicheTestWithParamImpl<T>;
 
 using QuicheFlagSaver = QuicheFlagSaverImpl;
 
@@ -21,17 +23,13 @@ inline std::string QuicheGetTestMemoryCachePath() {
   return QuicheGetTestMemoryCachePathImpl();
 }
 
-namespace quiche {
-namespace test {
-
 // Returns the path to quiche/common directory where the test data could be
 // located.
 inline std::string QuicheGetCommonSourcePath() {
   return QuicheGetCommonSourcePathImpl();
 }
 
-}  // namespace test
-}  // namespace quiche
+}  // namespace quiche::test
 
 #define EXPECT_QUICHE_DEBUG_DEATH(condition, message) \
   EXPECT_QUICHE_DEBUG_DEATH_IMPL(condition, message)

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

@@ -5,7 +5,7 @@
 #ifndef QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUIC_FLAGS_IMPL_H_
 #define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUIC_FLAGS_IMPL_H_
 
-#include <string>
+#include <cstdint>
 
 #include "quiche/common/platform/api/quiche_export.h"
 

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

@@ -7,8 +7,9 @@
 
 #include "quiche/common/platform/api/quiche_logging.h"
 
-#define QUICHE_BUG_IMPL(b) QUICHE_LOG(DFATAL)
-#define QUICHE_BUG_IF_IMPL(b, condition) QUICHE_LOG_IF(DFATAL, condition)
+#define QUICHE_BUG_IMPL(b) QUICHE_LOG(DFATAL) << #b ": "
+#define QUICHE_BUG_IF_IMPL(b, condition) \
+  QUICHE_LOG_IF(DFATAL, condition) << #b ": "
 #define QUICHE_PEER_BUG_IMPL(b) QUICHE_LOG(DFATAL)
 #define QUICHE_PEER_BUG_IF_IMPL(b, condition) QUICHE_LOG_IF(DFATAL, condition)