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

package/third_party/quiche/quiche/{common/balsa → balsa}/balsa_frame_test.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/balsa_frame.h"
+#include "quiche/balsa/balsa_frame.h"
 
 #include <stdlib.h>
 
@@ -15,20 +15,21 @@
 #include <utility>
 #include <vector>
 
-#include "absl/flags/flag.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_replace.h"
 #include "absl/strings/string_view.h"
-#include "quiche/common/balsa/balsa_enums.h"
-#include "quiche/common/balsa/balsa_headers.h"
-#include "quiche/common/balsa/balsa_visitor_interface.h"
-#include "quiche/common/balsa/http_validation_policy.h"
-#include "quiche/common/balsa/noop_balsa_visitor.h"
-#include "quiche/common/balsa/simple_buffer.h"
+#include "quiche/balsa/balsa_enums.h"
+#include "quiche/balsa/balsa_headers.h"
+#include "quiche/balsa/balsa_visitor_interface.h"
+#include "quiche/balsa/http_validation_policy.h"
+#include "quiche/balsa/noop_balsa_visitor.h"
+#include "quiche/balsa/simple_buffer.h"
+#include "quiche/common/platform/api/quiche_command_line_flags.h"
 #include "quiche/common/platform/api/quiche_expect_bug.h"
+#include "quiche/common/platform/api/quiche_flags.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 
@@ -43,9 +44,10 @@ using testing::Range;
 using testing::StrEq;
 using testing::StrictMock;
 
-ABSL_FLAG(std::string, randseed, "",
-          "This is the seed for Pseudo-random number"
-          " generator used when generating random messages for unittests");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, randseed, "",
+    "This is the seed for Pseudo-random number"
+    " generator used when generating random messages for unittests");
 
 namespace quiche {
 
@@ -880,7 +882,7 @@ void WhitespaceHeaderTestHelper(
   SCOPED_TRACE(EscapeString(message));
   size_t bytes_consumed = framer.ProcessInput(message.data(), message.size());
   EXPECT_EQ(message.size(), bytes_consumed);
-  if (expected_error_code == BalsaFrameEnums::NO_ERROR) {
+  if (expected_error_code == BalsaFrameEnums::BALSA_NO_ERROR) {
     EXPECT_EQ(false, framer.Error());
   } else {
     EXPECT_EQ(true, framer.Error());
@@ -910,13 +912,13 @@ TEST(HTTPBalsaFrame, WhitespaceInRequestsProcessedProperly) {
       "test: test\r\n"
       " continued\r\n"
       "\r\n",
-      true, BalsaFrameEnums::NO_ERROR);
+      true, BalsaFrameEnums::BALSA_NO_ERROR);
   WhitespaceHeaderTestHelper(
       "GET / HTTP/1.1\r\n"
       "test: test\r\n"
       " \r\n"
       "\r\n",
-      true, BalsaFrameEnums::NO_ERROR);
+      true, BalsaFrameEnums::BALSA_NO_ERROR);
 }
 
 TEST(HTTPBalsaFrame, WhitespaceInResponsesProcessedProperly) {
@@ -936,14 +938,14 @@ TEST(HTTPBalsaFrame, WhitespaceInResponsesProcessedProperly) {
       " continued\r\n"
       "Content-Length: 0\r\n"
       "\r\n",
-      false, BalsaFrameEnums::NO_ERROR);
+      false, BalsaFrameEnums::BALSA_NO_ERROR);
   WhitespaceHeaderTestHelper(
       "HTTP/1.0 200 Reason\r\n"
       "test: test\r\n"
       " \r\n"
       "Content-Length: 0\r\n"
       "\r\n",
-      false, BalsaFrameEnums::NO_ERROR);
+      false, BalsaFrameEnums::BALSA_NO_ERROR);
 }
 
 TEST_F(HTTPBalsaFrameTest, VisitorInvokedProperlyForTrivialRequest) {
@@ -1194,7 +1196,7 @@ TEST_F(HTTPBalsaFrameTest, NothingBadHappensWhenNoVisitorIsAssigned) {
   EXPECT_EQ(trailer.size(),
             balsa_frame_.ProcessInput(trailer.data(), trailer.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 TEST_F(HTTPBalsaFrameTest, NothingBadHappensWhenNoVisitorIsAssignedInResponse) {
@@ -1223,7 +1225,7 @@ TEST_F(HTTPBalsaFrameTest, NothingBadHappensWhenNoVisitorIsAssignedInResponse) {
   EXPECT_EQ(trailer.size(),
             balsa_frame_.ProcessInput(trailer.data(), trailer.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
   const absl::string_view crass = trailer_.GetHeader("crass");
   EXPECT_EQ("monkeys", crass);
   const absl::string_view funky = trailer_.GetHeader("funky");
@@ -1246,7 +1248,7 @@ TEST_F(HTTPBalsaFrameTest, TransferEncodingIdentityIsIgnored) {
   EXPECT_FALSE(balsa_frame_.MessageFullyRead());
   ASSERT_EQ(body.size(), balsa_frame_.ProcessInput(body.data(), body.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 TEST_F(HTTPBalsaFrameTest,
@@ -1274,7 +1276,7 @@ TEST_F(HTTPBalsaFrameTest,
   ASSERT_EQ(trailer.size(),
             balsa_frame_.ProcessInput(trailer.data(), trailer.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 TEST_F(HTTPBalsaFrameTest,
@@ -1305,7 +1307,7 @@ TEST_F(HTTPBalsaFrameTest,
   ASSERT_EQ(trailer.size(),
             balsa_frame_.ProcessInput(trailer.data(), trailer.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
   const absl::string_view crass = trailer_.GetHeader("crass");
   EXPECT_EQ("monkeys", crass);
   const absl::string_view funky = trailer_.GetHeader("funky");
@@ -1517,7 +1519,7 @@ TEST_F(HTTPBalsaFrameTest, VisitorInvokedProperlyForRequestWithContentLength) {
                                       message.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 TEST_F(HTTPBalsaFrameTest,
@@ -1553,7 +1555,7 @@ TEST_F(HTTPBalsaFrameTest,
                                       message.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 TEST_F(HTTPBalsaFrameTest,
@@ -1615,7 +1617,7 @@ TEST_F(HTTPBalsaFrameTest,
                                       message.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 
   EXPECT_EQ(message_body, body_input);
   EXPECT_EQ(message_body_data, body_data);
@@ -1687,7 +1689,7 @@ TEST_F(HTTPBalsaFrameTest,
                                       message.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 
   EXPECT_EQ(message_body, body_input);
   EXPECT_EQ(message_body_data, body_data);
@@ -1928,7 +1930,7 @@ TEST_F(HTTPBalsaFrameTest, VisitorInvokedProperlyForTrivialResponse) {
             balsa_frame_.ProcessInput(message.data(), message.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 TEST_F(HTTPBalsaFrameTest,
@@ -1961,7 +1963,7 @@ TEST_F(HTTPBalsaFrameTest,
                                      header_input.data(), header_input.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 TEST_F(HTTPBalsaFrameTest, VisitorInvokedProperlyForResponseWithBlankLines) {
@@ -1996,7 +1998,7 @@ TEST_F(HTTPBalsaFrameTest, VisitorInvokedProperlyForResponseWithBlankLines) {
             balsa_frame_.ProcessInput(message.data(), message.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 TEST_F(HTTPBalsaFrameTest, VisitorInvokedProperlyForResponseWithContentLength) {
@@ -2032,7 +2034,7 @@ TEST_F(HTTPBalsaFrameTest, VisitorInvokedProperlyForResponseWithContentLength) {
                                       message.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 TEST_F(HTTPBalsaFrameTest,
@@ -2091,7 +2093,7 @@ TEST_F(HTTPBalsaFrameTest,
                                       message.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 
   EXPECT_EQ(message_body, body_input);
   EXPECT_EQ(message_body_data, body_data);
@@ -2161,7 +2163,7 @@ TEST_F(HTTPBalsaFrameTest,
                                       message.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 
   EXPECT_EQ(message_body, body_input);
   EXPECT_EQ(message_body_data, body_data);
@@ -2236,7 +2238,7 @@ TEST_F(
   }
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 
   EXPECT_EQ(message_body, body_input);
   EXPECT_EQ(message_body_data, body_data);
@@ -2249,7 +2251,7 @@ TEST_F(
 TEST(HTTPBalsaFrame,
      VisitorInvokedProperlyForResponseWithTransferEncodingAndTrailersRandom) {
   TestSeed seed;
-  seed.Initialize(absl::GetFlag(FLAGS_randseed));
+  seed.Initialize(GetQuicheCommandLineFlag(FLAGS_randseed));
   RandomEngine rng;
   rng.seed(seed.GetSeed());
   for (int i = 0; i < 1000; ++i) {
@@ -2331,7 +2333,7 @@ TEST(HTTPBalsaFrame,
     EXPECT_EQ(message.size(), total_processed);
     EXPECT_TRUE(balsa_frame.MessageFullyRead());
     EXPECT_FALSE(balsa_frame.Error());
-    EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame.ErrorCode());
+    EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame.ErrorCode());
 
     EXPECT_EQ(message_body, body_input);
     EXPECT_EQ(message_body_data, body_data);
@@ -2403,7 +2405,7 @@ TEST_F(HTTPBalsaFrameTest, AppropriateActionTakenWhenHeadersTooLongWhenReset) {
   EXPECT_EQ(BalsaFrameEnums::HEADERS_TOO_LONG, balsa_frame_.ErrorCode());
 }
 
-class BalsaFrameParsingTest : public testing::Test {
+class BalsaFrameParsingTest : public QuicheTest {
  protected:
   void SetUp() override {
     balsa_frame_.set_http_validation_policy(
@@ -2878,10 +2880,10 @@ TEST_F(HTTPBalsaFrameTest, TwoSameContentHeadersIsNotAnError) {
       "\r\n"
       "1";
   balsa_frame_.ProcessInput(header.data(), header.size());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
   EXPECT_FALSE(balsa_frame_.Error());
   balsa_frame_.ProcessInput(header.data(), header.size());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
   EXPECT_FALSE(balsa_frame_.Error());
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
 }
@@ -3170,7 +3172,7 @@ TEST_F(HTTPBalsaFrameTest, MultipleHeadersInTrailer) {
   std::map<std::string, std::string>::const_iterator iter;
   std::string trailer_data;
   TestSeed seed;
-  seed.Initialize(absl::GetFlag(FLAGS_randseed));
+  seed.Initialize(GetQuicheCommandLineFlag(FLAGS_randseed));
   RandomEngine rng;
   rng.seed(seed.GetSeed());
   FakeHeaders fake_headers_in_trailer;
@@ -3223,7 +3225,7 @@ TEST_F(HTTPBalsaFrameTest, MultipleHeadersInTrailer) {
                                      trailer_data.data(), trailer_data.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 
   EXPECT_EQ(chunks, body_input);
 
@@ -3261,7 +3263,7 @@ TEST_F(HTTPBalsaFrameTest, NothingBadHappensWithNULLTrailer) {
             balsa_frame_.ProcessInput(trailer.data(), trailer.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 // Test Reset() correctly resets trailer related states.
@@ -3291,7 +3293,7 @@ TEST_F(HTTPBalsaFrameTest, FrameAndResetAndFrameAgain) {
             balsa_frame_.ProcessInput(trailer.data(), trailer.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 
   absl::string_view value = trailer_.GetHeader("k");
   EXPECT_EQ("v", value);
@@ -3319,7 +3321,7 @@ TEST_F(HTTPBalsaFrameTest, FrameAndResetAndFrameAgain) {
             balsa_frame_.ProcessInput(trailer.data(), trailer.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 
   value = trailer_.GetHeader("k");
   EXPECT_TRUE(value.empty());
@@ -3482,31 +3484,33 @@ TEST_F(HTTPBalsaFrameTest, InvalidCharsAreCounted) {
 // Test gibberish in headers and trailer. GFE does not crash but garbage in
 // garbage out.
 TEST_F(HTTPBalsaFrameTest, GibberishInHeadersAndTrailer) {
-  const char kGibberish1[] = {138, 175, 233, 0};
-  const char kGibberish2[] = {'?', '?', 128, 255, 129, 254, 0};
+  // Use static_cast<char> for values exceeding SCHAR_MAX to make sure this
+  // compiles on platforms where char is signed.
+  const char kGibberish1[] = {static_cast<char>(138), static_cast<char>(175),
+                              static_cast<char>(233), 0};
+  const char kGibberish2[] = {'?',
+                              '?',
+                              static_cast<char>(128),
+                              static_cast<char>(255),
+                              static_cast<char>(129),
+                              static_cast<char>(254),
+                              0};
   const char kGibberish3[] = "foo: bar : eeep : baz";
 
-  std::string gibberish_headers;
-  gibberish_headers += kGibberish1;
-  gibberish_headers += ":";
-  gibberish_headers += kGibberish2;
-  gibberish_headers += "\r\n";
-  gibberish_headers += kGibberish3;
-  gibberish_headers += "\r\n";
+  std::string gibberish_headers =
+      absl::StrCat(kGibberish1, ":", kGibberish2, "\r\n", kGibberish3, "\r\n");
 
-  std::string headers =
+  std::string headers = absl::StrCat(
       "HTTP/1.1 200 OK\r\n"
-      "transfer-encoding: chunked\r\n";
-  headers += gibberish_headers;
-  headers += "\r\n";
+      "transfer-encoding: chunked\r\n",
+      gibberish_headers, "\r\n");
 
   std::string chunks =
       "3\r\n"
       "123\r\n"
       "0\r\n";
-  std::string trailer = "k: v\n";
-  trailer += gibberish_headers;
-  trailer += "\n";
+
+  std::string trailer = absl::StrCat("k: v\n", gibberish_headers, "\n");
 
   balsa_frame_.set_is_request(false);
   balsa_frame_.set_balsa_trailer(&trailer_);
@@ -3520,7 +3524,7 @@ TEST_F(HTTPBalsaFrameTest, GibberishInHeadersAndTrailer) {
             balsa_frame_.ProcessInput(trailer.data(), trailer.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 
   // Transfer-encoding can be multi-valued, so GetHeader does not work.
   EXPECT_TRUE(headers_.transfer_encoding_is_chunked());
@@ -3608,7 +3612,7 @@ TEST_F(HTTPBalsaFrameTest,
             balsa_frame_.ProcessInput(trailer.data(), trailer.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 // Handle two sets of headers when set up properly and the first is 100
@@ -3636,7 +3640,7 @@ TEST_F(HTTPBalsaFrameTest, Support100Continue) {
   ASSERT_EQ(body.size(), balsa_frame_.ProcessInput(body.data(), body.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 // Handle two sets of headers when set up properly and the first is 100
@@ -3664,7 +3668,7 @@ TEST_F(HTTPBalsaFrameTest, Support100Continue401Unauthorized) {
   ASSERT_EQ(body.size(), balsa_frame_.ProcessInput(body.data(), body.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 TEST_F(HTTPBalsaFrameTest, Support100ContinueRunTogether) {
@@ -3693,7 +3697,7 @@ TEST_F(HTTPBalsaFrameTest, Support100ContinueRunTogether) {
   ASSERT_EQ(body.size(), balsa_frame_.ProcessInput(body.data(), body.size()));
   EXPECT_TRUE(balsa_frame_.MessageFullyRead());
   EXPECT_FALSE(balsa_frame_.Error());
-  EXPECT_EQ(BalsaFrameEnums::NO_ERROR, balsa_frame_.ErrorCode());
+  EXPECT_EQ(BalsaFrameEnums::BALSA_NO_ERROR, balsa_frame_.ErrorCode());
 }
 
 }  // namespace

package/third_party/quiche/quiche/{common/balsa → balsa}/balsa_headers.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/balsa_headers.h"
+#include "quiche/balsa/balsa_headers.h"
 
 #include <sys/types.h>
 
@@ -19,8 +19,8 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "quiche/common/balsa/balsa_enums.h"
-#include "quiche/common/balsa/header_properties.h"
+#include "quiche/balsa/balsa_enums.h"
+#include "quiche/balsa/header_properties.h"
 #include "quiche/common/platform/api/quiche_header_policy.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 
@@ -182,8 +182,12 @@ void BalsaHeaders::ParseTokenList(absl::string_view header_value,
   const char* start = header_value.begin();
   const char* end = header_value.end();
   while (true) {
+    // Cast `*start` to unsigned char to make values above 127 rank as expected
+    // on platforms with signed char, where such values are represented as
+    // negative numbers before the cast.
+
     // search for first nonwhitespace, non separator char.
-    while (*start == ',' || *start <= ' ') {
+    while (*start == ',' || static_cast<unsigned char>(*start) <= ' ') {
       ++start;
       if (start == end) {
         return;
@@ -193,7 +197,7 @@ void BalsaHeaders::ParseTokenList(absl::string_view header_value,
     const char* nws = start;
 
     // search for next whitspace or separator char.
-    while (*start != ',' && *start > ' ') {
+    while (*start != ',' && static_cast<unsigned char>(*start) > ' ') {
       ++start;
       if (start == end) {
         if (nws != start) {
@@ -784,13 +788,10 @@ size_t BalsaHeaders::RemoveValue(absl::string_view key,
       bool found = absl::StartsWith(values, needle);
 
       // Find the entirety of this value (including trailing comma if existent).
-      bool comma_found = false;
-      size_t cur_size = 0;
-
-        const size_t next_comma =
-            values.find(',', /* pos = */ found ? needle.size() : 0);
-        comma_found = next_comma != absl::string_view::npos;
-        cur_size = (comma_found ? next_comma + 1 : values.size());
+      const size_t next_comma =
+          values.find(',', /* pos = */ (found ? needle.size() : 0));
+      const bool comma_found = next_comma != absl::string_view::npos;
+      const size_t cur_size = (comma_found ? next_comma + 1 : values.size());
 
       // Make sure that our prefix match is a full match.
       if (found && cur_size != needle.size()) {

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

@@ -4,8 +4,8 @@
 
 // A lightweight implementation for storing HTTP headers.
 
-#ifndef QUICHE_COMMON_BALSA_BALSA_HEADERS_H_
-#define QUICHE_COMMON_BALSA_BALSA_HEADERS_H_
+#ifndef QUICHE_BALSA_BALSA_HEADERS_H_
+#define QUICHE_BALSA_BALSA_HEADERS_H_
 
 #include <cstddef>
 #include <cstring>
@@ -17,14 +17,16 @@
 #include <utility>
 #include <vector>
 
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "quiche/common/balsa/balsa_enums.h"
-#include "quiche/common/balsa/header_api.h"
-#include "quiche/common/balsa/standard_header_map.h"
+#include "quiche/balsa/balsa_enums.h"
+#include "quiche/balsa/header_api.h"
+#include "quiche/balsa/standard_header_map.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/platform/api/quiche_logging.h"
@@ -517,6 +519,9 @@ class QUICHE_EXPORT_PRIVATE BalsaHeaders : public HeaderApi {
   // Returns the value corresponding to the given header key. Returns an empty
   // string if the header key does not exist. For headers that may consist of
   // multiple lines, use GetAllOfHeader() instead.
+  // Make the QuicheLowerCaseString overload visible,
+  // and only override the absl::string_view one.
+  using HeaderApi::GetHeader;
   absl::string_view GetHeader(absl::string_view key) const override;
 
   // Iterates over all currently valid header lines, appending their
@@ -545,7 +550,8 @@ class QUICHE_EXPORT_PRIVATE BalsaHeaders : public HeaderApi {
   // See gfe::header_properties::IsMultivaluedHeader() for which headers
   // GFE treats as being multivalued.
 
-  // Make all methods in this overload set visible, and override just one.
+  // Make the QuicheLowerCaseString overload visible,
+  // and only override the absl::string_view one.
   using HeaderApi::GetAllOfHeader;
   void GetAllOfHeader(absl::string_view key,
                       std::vector<absl::string_view>* out) const override;
@@ -557,6 +563,9 @@ class QUICHE_EXPORT_PRIVATE BalsaHeaders : public HeaderApi {
                                     std::vector<absl::string_view>* out) const;
 
   // Joins all values for `key` into a comma-separated string.
+  // Make the QuicheLowerCaseString overload visible,
+  // and only override the absl::string_view one.
+  using HeaderApi::GetAllOfHeaderAsString;
   std::string GetAllOfHeaderAsString(absl::string_view key) const override;
 
   // Determine if a given header is present.  Case-insensitive.
@@ -1337,7 +1346,6 @@ BalsaHeaders::header_lines_key_end() const {
 inline void BalsaHeaders::erase(const const_header_lines_iterator& it) {
   QUICHE_DCHECK_EQ(it.headers_, this);
   QUICHE_DCHECK_LT(it.idx_, header_lines_.size());
-  QUICHE_DCHECK_GE(it.idx_, 0u);
   header_lines_[it.idx_].skip = true;
 }
 
@@ -1466,4 +1474,4 @@ const IteratorType BalsaHeaders::HeaderLinesEndHelper() const {
 
 }  // namespace quiche
 
-#endif  // QUICHE_COMMON_BALSA_BALSA_HEADERS_H_
+#endif  // QUICHE_BALSA_BALSA_HEADERS_H_

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

@@ -6,7 +6,7 @@
 // tested in the balsa_frame_test as the BalsaFrame and
 // BalsaHeaders classes are fairly related.
 
-#include "quiche/common/balsa/balsa_headers.h"
+#include "quiche/balsa/balsa_headers.h"
 
 #include <cstring>
 #include <limits>
@@ -22,12 +22,12 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "quiche/common/balsa/balsa_enums.h"
-#include "quiche/common/balsa/balsa_frame.h"
-#include "quiche/common/balsa/simple_buffer.h"
+#include "quiche/balsa/balsa_enums.h"
+#include "quiche/balsa/balsa_frame.h"
+#include "quiche/balsa/simple_buffer.h"
+#include "quiche/common/platform/api/quiche_expect_bug.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 absl::make_unique;
 using testing::AnyOf;
@@ -837,11 +837,11 @@ TEST(BalsaHeaders, TestRemovingValues) {
       EXPECT_TRUE(headers.HeaderHasValue(key, value2));
       EXPECT_EQ(value, headers.GetAllOfHeaderAsString(key));
 
-        EXPECT_EQ(1u, headers.RemoveValue(key, value2));
+      EXPECT_EQ(1u, headers.RemoveValue(key, value2));
 
-        EXPECT_TRUE(headers.HeaderHasValue(key, value1));
-        EXPECT_FALSE(headers.HeaderHasValue(key, value2));
-        EXPECT_EQ(value1, headers.GetAllOfHeaderAsString(key));
+      EXPECT_TRUE(headers.HeaderHasValue(key, value1));
+      EXPECT_FALSE(headers.HeaderHasValue(key, value2));
+      EXPECT_EQ(value1, headers.GetAllOfHeaderAsString(key));
     }
 
     {

package/third_party/quiche/quiche/{common/balsa → balsa}/balsa_visitor_interface.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_BALSA_VISITOR_INTERFACE_H_
-#define QUICHE_COMMON_BALSA_BALSA_VISITOR_INTERFACE_H_
+#ifndef QUICHE_BALSA_BALSA_VISITOR_INTERFACE_H_
+#define QUICHE_BALSA_BALSA_VISITOR_INTERFACE_H_
 
 #include <cstddef>
 
 #include "absl/strings/string_view.h"
-#include "quiche/common/balsa/balsa_enums.h"
+#include "quiche/balsa/balsa_enums.h"
 #include "quiche/common/platform/api/quiche_export.h"
 
 namespace quiche {
@@ -145,4 +145,4 @@ class QUICHE_EXPORT_PRIVATE BalsaVisitorInterface {
 
 }  // namespace quiche
 
-#endif  // QUICHE_COMMON_BALSA_BALSA_VISITOR_INTERFACE_H_
+#endif  // QUICHE_BALSA_BALSA_VISITOR_INTERFACE_H_

package/third_party/quiche/quiche/{common/balsa → balsa}/framer_interface.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_FRAMER_INTERFACE_H_
-#define QUICHE_COMMON_BALSA_FRAMER_INTERFACE_H_
+#ifndef QUICHE_BALSA_FRAMER_INTERFACE_H_
+#define QUICHE_BALSA_FRAMER_INTERFACE_H_
 
 #include <cstddef>
 
@@ -21,4 +21,4 @@ class QUICHE_EXPORT_PRIVATE FramerInterface {
 
 }  // namespace quiche
 
-#endif  // QUICHE_COMMON_BALSA_FRAMER_INTERFACE_H_
+#endif  // QUICHE_BALSA_FRAMER_INTERFACE_H_

package/third_party/quiche/quiche/{common/balsa → balsa}/header_api.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_HEADER_API_H_
-#define QUICHE_COMMON_BALSA_HEADER_API_H_
+#ifndef QUICHE_BALSA_HEADER_API_H_
+#define QUICHE_BALSA_HEADER_API_H_
 
 #include <cstddef>
 #include <functional>
@@ -271,4 +271,4 @@ class QUICHE_EXPORT_PRIVATE HeaderApi : public virtual ConstHeaderApi {
 
 }  // namespace quiche
 
-#endif  // QUICHE_COMMON_BALSA_HEADER_API_H_
+#endif  // QUICHE_BALSA_HEADER_API_H_

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

@@ -1,4 +1,4 @@
-#include "quiche/common/balsa/header_properties.h"
+#include "quiche/balsa/header_properties.h"
 
 #include <array>
 

package/third_party/quiche/quiche/{common/balsa → balsa}/header_properties.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_HEADER_PROPERTIES_H_
-#define QUICHE_COMMON_BALSA_HEADER_PROPERTIES_H_
+#ifndef QUICHE_BALSA_HEADER_PROPERTIES_H_
+#define QUICHE_BALSA_HEADER_PROPERTIES_H_
 
 #include <cstdint>
 
@@ -47,4 +47,4 @@ QUICHE_EXPORT_PRIVATE bool HasInvalidHeaderChars(absl::string_view value);
 
 }  // namespace quiche::header_properties
 
-#endif  // QUICHE_COMMON_BALSA_HEADER_PROPERTIES_H_
+#endif  // QUICHE_BALSA_HEADER_PROPERTIES_H_