Move QuicheTextUtils out of platform.
All methods are now defined in terms of Abseil or STL, there is no need
for QuicheTextUtils to live in platform.
PiperOrigin-RevId: 370889335
Change-Id: Id75b2f7c6d694481eea17d85690ce12bca03f917
diff --git a/common/quiche_data_reader.cc b/common/quiche_data_reader.cc
index c196b42..f20c752 100644
--- a/common/quiche_data_reader.cc
+++ b/common/quiche_data_reader.cc
@@ -10,7 +10,6 @@
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "common/platform/api/quiche_logging.h"
-#include "common/platform/api/quiche_text_utils.h"
#include "common/quiche_endian.h"
namespace quiche {
diff --git a/common/quiche_text_utils.cc b/common/quiche_text_utils.cc
new file mode 100644
index 0000000..263c97e
--- /dev/null
+++ b/common/quiche_text_utils.cc
@@ -0,0 +1,77 @@
+// Copyright 2021 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 "common/quiche_text_utils.h"
+
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+
+namespace quiche {
+
+// static
+void QuicheTextUtils::Base64Encode(const uint8_t* data,
+ size_t data_len,
+ std::string* output) {
+ absl::Base64Escape(std::string(reinterpret_cast<const char*>(data), data_len),
+ output);
+ // Remove padding.
+ size_t len = output->size();
+ if (len >= 2) {
+ if ((*output)[len - 1] == '=') {
+ len--;
+ if ((*output)[len - 1] == '=') {
+ len--;
+ }
+ output->resize(len);
+ }
+ }
+}
+
+// static
+absl::optional<std::string> QuicheTextUtils::Base64Decode(
+ absl::string_view input) {
+ std::string output;
+ if (!absl::Base64Unescape(input, &output)) {
+ return absl::nullopt;
+ }
+ return output;
+}
+
+// static
+std::string QuicheTextUtils::HexDump(absl::string_view binary_data) {
+ const int kBytesPerLine = 16; // Maximum bytes dumped per line.
+ int offset = 0;
+ const char* p = binary_data.data();
+ int bytes_remaining = binary_data.size();
+ std::string output;
+ while (bytes_remaining > 0) {
+ const int line_bytes = std::min(bytes_remaining, kBytesPerLine);
+ absl::StrAppendFormat(&output, "0x%04x: ", offset);
+ for (int i = 0; i < kBytesPerLine; ++i) {
+ if (i < line_bytes) {
+ absl::StrAppendFormat(&output, "%02x",
+ static_cast<unsigned char>(p[i]));
+ } else {
+ absl::StrAppend(&output, " ");
+ }
+ if (i % 2) {
+ absl::StrAppend(&output, " ");
+ }
+ }
+ absl::StrAppend(&output, " ");
+ for (int i = 0; i < line_bytes; ++i) {
+ // Replace non-printable characters and 0x20 (space) with '.'
+ output += absl::ascii_isgraph(p[i]) ? p[i] : '.';
+ }
+
+ bytes_remaining -= line_bytes;
+ offset += line_bytes;
+ p += line_bytes;
+ absl::StrAppend(&output, "\n");
+ }
+ return output;
+}
+
+} // namespace quiche
diff --git a/common/platform/api/quiche_text_utils.h b/common/quiche_text_utils.h
similarity index 66%
rename from common/platform/api/quiche_text_utils.h
rename to common/quiche_text_utils.h
index 42b4115..c99d9e2 100644
--- a/common/platform/api/quiche_text_utils.h
+++ b/common/quiche_text_utils.h
@@ -2,16 +2,16 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef QUICHE_COMMON_PLATFORM_API_QUICHE_TEXT_UTILS_H_
-#define QUICHE_COMMON_PLATFORM_API_QUICHE_TEXT_UTILS_H_
+#ifndef QUICHE_COMMON_QUICHE_TEXT_UTILS_H_
+#define QUICHE_COMMON_QUICHE_TEXT_UTILS_H_
#include <string>
+#include "absl/strings/ascii.h"
#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "common/platform/api/quiche_export.h"
-#include "net/quiche/common/platform/impl/quiche_text_utils_impl.h"
namespace quiche {
@@ -20,47 +20,41 @@
public:
// Returns a new string in which |data| has been converted to lower case.
static std::string ToLower(absl::string_view data) {
- return quiche::QuicheTextUtilsImpl::ToLower(data);
+ return absl::AsciiStrToLower(data);
}
// Removes leading and trailing whitespace from |data|.
static void RemoveLeadingAndTrailingWhitespace(absl::string_view* data) {
- quiche::QuicheTextUtilsImpl::RemoveLeadingAndTrailingWhitespace(data);
+ *data = absl::StripAsciiWhitespace(*data);
}
// Base64 encodes with no padding |data_len| bytes of |data| into |output|.
static void Base64Encode(const uint8_t* data,
size_t data_len,
- std::string* output) {
- return quiche::QuicheTextUtilsImpl::Base64Encode(data, data_len, output);
- }
+ std::string* output);
// Decodes a base64-encoded |input|. Returns nullopt when the input is
// invalid.
- static absl::optional<std::string> Base64Decode(absl::string_view input) {
- return quiche::QuicheTextUtilsImpl::Base64Decode(input);
- }
+ static absl::optional<std::string> Base64Decode(absl::string_view input);
// Returns a string containing hex and ASCII representations of |binary|,
// side-by-side in the style of hexdump. Non-printable characters will be
// printed as '.' in the ASCII output.
// For example, given the input "Hello, QUIC!\01\02\03\04", returns:
// "0x0000: 4865 6c6c 6f2c 2051 5549 4321 0102 0304 Hello,.QUIC!...."
- static std::string HexDump(absl::string_view binary_data) {
- return quiche::QuicheTextUtilsImpl::HexDump(binary_data);
- }
+ static std::string HexDump(absl::string_view binary_data);
// Returns true if |data| contains any uppercase characters.
static bool ContainsUpperCase(absl::string_view data) {
- return quiche::QuicheTextUtilsImpl::ContainsUpperCase(data);
+ return std::any_of(data.begin(), data.end(), absl::ascii_isupper);
}
// Returns true if |data| contains only decimal digits.
static bool IsAllDigits(absl::string_view data) {
- return quiche::QuicheTextUtilsImpl::IsAllDigits(data);
+ return std::all_of(data.begin(), data.end(), absl::ascii_isdigit);
}
};
} // namespace quiche
-#endif // QUICHE_COMMON_PLATFORM_API_QUICHE_TEXT_UTILS_H_
+#endif // QUICHE_COMMON_QUICHE_TEXT_UTILS_H_
diff --git a/common/platform/api/quiche_text_utils_test.cc b/common/quiche_text_utils_test.cc
similarity index 91%
rename from common/platform/api/quiche_text_utils_test.cc
rename to common/quiche_text_utils_test.cc
index 4372c07..5c10cbf 100644
--- a/common/platform/api/quiche_text_utils_test.cc
+++ b/common/quiche_text_utils_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 "common/platform/api/quiche_text_utils.h"
+#include "common/quiche_text_utils.h"
#include <string>
@@ -12,9 +12,7 @@
namespace quiche {
namespace test {
-class QuicheTextUtilsTest : public QuicheTest {};
-
-TEST_F(QuicheTextUtilsTest, ToLower) {
+TEST(QuicheTextUtilsTest, ToLower) {
EXPECT_EQ("lower", quiche::QuicheTextUtils::ToLower("LOWER"));
EXPECT_EQ("lower", quiche::QuicheTextUtils::ToLower("lower"));
EXPECT_EQ("lower", quiche::QuicheTextUtils::ToLower("lOwEr"));
@@ -22,7 +20,7 @@
EXPECT_EQ("", quiche::QuicheTextUtils::ToLower(""));
}
-TEST_F(QuicheTextUtilsTest, RemoveLeadingAndTrailingWhitespace) {
+TEST(QuicheTextUtilsTest, RemoveLeadingAndTrailingWhitespace) {
std::string input;
for (auto* input : {"text", " text", " text", "text ", "text ", " text ",
@@ -33,7 +31,7 @@
}
}
-TEST_F(QuicheTextUtilsTest, HexDump) {
+TEST(QuicheTextUtilsTest, HexDump) {
// Verify output for empty input.
EXPECT_EQ("", quiche::QuicheTextUtils::HexDump(absl::HexStringToBytes("")));
// Verify output of the HexDump method is as expected.
@@ -64,7 +62,7 @@
quiche::QuicheTextUtils::HexDump(absl::HexStringToBytes("90aaff")));
}
-TEST_F(QuicheTextUtilsTest, Base64Encode) {
+TEST(QuicheTextUtilsTest, Base64Encode) {
std::string output;
std::string input = "Hello";
quiche::QuicheTextUtils::Base64Encode(
@@ -82,7 +80,7 @@
output);
}
-TEST_F(QuicheTextUtilsTest, ContainsUpperCase) {
+TEST(QuicheTextUtilsTest, ContainsUpperCase) {
EXPECT_FALSE(quiche::QuicheTextUtils::ContainsUpperCase("abc"));
EXPECT_FALSE(quiche::QuicheTextUtils::ContainsUpperCase(""));
EXPECT_FALSE(quiche::QuicheTextUtils::ContainsUpperCase("123"));
