Replace quiche::QuicheStringPiece with absl::string_view.
PiperOrigin-RevId: 336380679
Change-Id: Ib7b99bfe16215b15258d1ca67cd097e28c9b1289
diff --git a/common/platform/api/quiche_str_cat_test.cc b/common/platform/api/quiche_str_cat_test.cc
index 7085b8a..c9a5bfc 100644
--- a/common/platform/api/quiche_str_cat_test.cc
+++ b/common/platform/api/quiche_str_cat_test.cc
@@ -6,7 +6,7 @@
#include <string>
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_test.h"
namespace quiche {
@@ -46,7 +46,7 @@
std::string strs[] = {"Hello", "Cruel", "World"};
- QuicheStringPiece pieces[] = {"Hello", "Cruel", "World"};
+ absl::string_view pieces[] = {"Hello", "Cruel", "World"};
const char* c_strs[] = {"Hello", "Cruel", "World"};
diff --git a/common/platform/api/quiche_text_utils.h b/common/platform/api/quiche_text_utils.h
index 2cf920f..0aab251 100644
--- a/common/platform/api/quiche_text_utils.h
+++ b/common/platform/api/quiche_text_utils.h
@@ -7,9 +7,9 @@
#include <string>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_optional.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/quiche/common/platform/impl/quiche_text_utils_impl.h"
namespace quiche {
@@ -18,55 +18,52 @@
class QUICHE_EXPORT QuicheTextUtils {
public:
// Returns true if |data| starts with |prefix|, case sensitively.
- static bool StartsWith(quiche::QuicheStringPiece data,
- quiche::QuicheStringPiece prefix) {
+ static bool StartsWith(absl::string_view data, absl::string_view prefix) {
return quiche::QuicheTextUtilsImpl::StartsWith(data, prefix);
}
// Returns true if |data| ends with |suffix|, case sensitively.
- static bool EndsWith(quiche::QuicheStringPiece data,
- quiche::QuicheStringPiece suffix) {
+ static bool EndsWith(absl::string_view data, absl::string_view suffix) {
return quiche::QuicheTextUtilsImpl::EndsWith(data, suffix);
}
// Returns true if |data| ends with |suffix|, case insensitively.
- static bool EndsWithIgnoreCase(quiche::QuicheStringPiece data,
- quiche::QuicheStringPiece suffix) {
+ static bool EndsWithIgnoreCase(absl::string_view data,
+ absl::string_view suffix) {
return quiche::QuicheTextUtilsImpl::EndsWithIgnoreCase(data, suffix);
}
// Returns a new string in which |data| has been converted to lower case.
- static std::string ToLower(quiche::QuicheStringPiece data) {
+ static std::string ToLower(absl::string_view data) {
return quiche::QuicheTextUtilsImpl::ToLower(data);
}
// Removes leading and trailing whitespace from |data|.
- static void RemoveLeadingAndTrailingWhitespace(
- quiche::QuicheStringPiece* data) {
+ static void RemoveLeadingAndTrailingWhitespace(absl::string_view* data) {
quiche::QuicheTextUtilsImpl::RemoveLeadingAndTrailingWhitespace(data);
}
// Returns true if |in| represents a valid uint64, and stores that value in
// |out|.
- static bool StringToUint64(quiche::QuicheStringPiece in, uint64_t* out) {
+ static bool StringToUint64(absl::string_view in, uint64_t* out) {
return quiche::QuicheTextUtilsImpl::StringToUint64(in, out);
}
// Returns true if |in| represents a valid int, and stores that value in
// |out|.
- static bool StringToInt(quiche::QuicheStringPiece in, int* out) {
+ static bool StringToInt(absl::string_view in, int* out) {
return quiche::QuicheTextUtilsImpl::StringToInt(in, out);
}
// Returns true if |in| represents a valid uint32, and stores that value in
// |out|.
- static bool StringToUint32(quiche::QuicheStringPiece in, uint32_t* out) {
+ static bool StringToUint32(absl::string_view in, uint32_t* out) {
return quiche::QuicheTextUtilsImpl::StringToUint32(in, out);
}
// Returns true if |in| represents a valid size_t, and stores that value in
// |out|.
- static bool StringToSizeT(quiche::QuicheStringPiece in, size_t* out) {
+ static bool StringToSizeT(absl::string_view in, size_t* out) {
return quiche::QuicheTextUtilsImpl::StringToSizeT(in, out);
}
@@ -79,13 +76,13 @@
// hexadecimal representation.
// Return value: 2*|length| characters of ASCII string.
static std::string HexEncode(const char* data, size_t length) {
- return HexEncode(quiche::QuicheStringPiece(data, length));
+ return HexEncode(absl::string_view(data, length));
}
// This converts |data.length()| bytes of binary to a
// 2*|data.length()|-character hexadecimal representation.
// Return value: 2*|data.length()| characters of ASCII string.
- static std::string HexEncode(quiche::QuicheStringPiece data) {
+ static std::string HexEncode(absl::string_view data) {
return quiche::QuicheTextUtilsImpl::HexEncode(data);
}
@@ -97,7 +94,7 @@
// Converts |data| from a hexadecimal ASCII string to a binary string
// that is |data.length()/2| bytes long.
- static std::string HexDecode(quiche::QuicheStringPiece data) {
+ static std::string HexDecode(absl::string_view data) {
return quiche::QuicheTextUtilsImpl::HexDecode(data);
}
@@ -110,7 +107,7 @@
// Decodes a base64-encoded |input|. Returns nullopt when the input is
// invalid.
- static QuicheOptional<std::string> Base64Decode(QuicheStringPiece input) {
+ static QuicheOptional<std::string> Base64Decode(absl::string_view input) {
return quiche::QuicheTextUtilsImpl::Base64Decode(input);
}
@@ -119,24 +116,23 @@
// 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(quiche::QuicheStringPiece binary_data) {
+ static std::string HexDump(absl::string_view binary_data) {
return quiche::QuicheTextUtilsImpl::HexDump(binary_data);
}
// Returns true if |data| contains any uppercase characters.
- static bool ContainsUpperCase(quiche::QuicheStringPiece data) {
+ static bool ContainsUpperCase(absl::string_view data) {
return quiche::QuicheTextUtilsImpl::ContainsUpperCase(data);
}
// Returns true if |data| contains only decimal digits.
- static bool IsAllDigits(quiche::QuicheStringPiece data) {
+ static bool IsAllDigits(absl::string_view data) {
return quiche::QuicheTextUtilsImpl::IsAllDigits(data);
}
// Splits |data| into a vector of pieces delimited by |delim|.
- static std::vector<quiche::QuicheStringPiece> Split(
- quiche::QuicheStringPiece data,
- char delim) {
+ static std::vector<absl::string_view> Split(absl::string_view data,
+ char delim) {
return quiche::QuicheTextUtilsImpl::Split(data, delim);
}
};
diff --git a/common/platform/api/quiche_text_utils_test.cc b/common/platform/api/quiche_text_utils_test.cc
index 1ca75d2..c2f302d 100644
--- a/common/platform/api/quiche_text_utils_test.cc
+++ b/common/platform/api/quiche_text_utils_test.cc
@@ -48,7 +48,7 @@
for (auto* input : {"text", " text", " text", "text ", "text ", " text ",
" text ", "\r\n\ttext", "text\n\r\t"}) {
- quiche::QuicheStringPiece piece(input);
+ absl::string_view piece(input);
quiche::QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&piece);
EXPECT_EQ("text", piece);
}
@@ -214,16 +214,16 @@
}
TEST_F(QuicheTextUtilsTest, Split) {
- EXPECT_EQ(std::vector<quiche::QuicheStringPiece>({"a", "b", "c"}),
+ EXPECT_EQ(std::vector<absl::string_view>({"a", "b", "c"}),
quiche::QuicheTextUtils::Split("a,b,c", ','));
- EXPECT_EQ(std::vector<quiche::QuicheStringPiece>({"a", "b", "c"}),
+ EXPECT_EQ(std::vector<absl::string_view>({"a", "b", "c"}),
quiche::QuicheTextUtils::Split("a:b:c", ':'));
- EXPECT_EQ(std::vector<quiche::QuicheStringPiece>({"a:b:c"}),
+ EXPECT_EQ(std::vector<absl::string_view>({"a:b:c"}),
quiche::QuicheTextUtils::Split("a:b:c", ','));
// Leading and trailing whitespace is preserved.
- EXPECT_EQ(std::vector<quiche::QuicheStringPiece>({"a", "b", "c"}),
+ EXPECT_EQ(std::vector<absl::string_view>({"a", "b", "c"}),
quiche::QuicheTextUtils::Split("a,b,c", ','));
- EXPECT_EQ(std::vector<quiche::QuicheStringPiece>({" a", "b ", " c "}),
+ EXPECT_EQ(std::vector<absl::string_view>({" a", "b ", " c "}),
quiche::QuicheTextUtils::Split(" a:b : c ", ':'));
}
diff --git a/common/quiche_data_reader.cc b/common/quiche_data_reader.cc
index 2242fea..9d76e05 100644
--- a/common/quiche_data_reader.cc
+++ b/common/quiche_data_reader.cc
@@ -6,15 +6,15 @@
#include <cstring>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_logging.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quiche {
-QuicheDataReader::QuicheDataReader(quiche::QuicheStringPiece data)
+QuicheDataReader::QuicheDataReader(absl::string_view data)
: QuicheDataReader(data.data(), data.length(), quiche::NETWORK_BYTE_ORDER) {
}
@@ -77,7 +77,7 @@
return true;
}
-bool QuicheDataReader::ReadStringPiece16(quiche::QuicheStringPiece* result) {
+bool QuicheDataReader::ReadStringPiece16(absl::string_view* result) {
// Read resultant length.
uint16_t result_len;
if (!ReadUInt16(&result_len)) {
@@ -88,7 +88,7 @@
return ReadStringPiece(result, result_len);
}
-bool QuicheDataReader::ReadStringPiece8(quiche::QuicheStringPiece* result) {
+bool QuicheDataReader::ReadStringPiece8(absl::string_view* result) {
// Read resultant length.
uint8_t result_len;
if (!ReadUInt8(&result_len)) {
@@ -99,8 +99,7 @@
return ReadStringPiece(result, result_len);
}
-bool QuicheDataReader::ReadStringPiece(quiche::QuicheStringPiece* result,
- size_t size) {
+bool QuicheDataReader::ReadStringPiece(absl::string_view* result, size_t size) {
// Make sure that we have enough data to read.
if (!CanRead(size)) {
OnFailure();
@@ -108,7 +107,7 @@
}
// Set result.
- *result = quiche::QuicheStringPiece(data_ + pos_, size);
+ *result = absl::string_view(data_ + pos_, size);
// Iterate.
pos_ += size;
@@ -121,7 +120,7 @@
}
bool QuicheDataReader::ReadDecimal64(size_t num_digits, uint64_t* result) {
- quiche::QuicheStringPiece digits;
+ absl::string_view digits;
if (!ReadStringPiece(&digits, num_digits)) {
return false;
}
@@ -129,22 +128,22 @@
return QuicheTextUtils::StringToUint64(digits, result);
}
-quiche::QuicheStringPiece QuicheDataReader::ReadRemainingPayload() {
- quiche::QuicheStringPiece payload = PeekRemainingPayload();
+absl::string_view QuicheDataReader::ReadRemainingPayload() {
+ absl::string_view payload = PeekRemainingPayload();
pos_ = len_;
return payload;
}
-quiche::QuicheStringPiece QuicheDataReader::PeekRemainingPayload() const {
- return quiche::QuicheStringPiece(data_ + pos_, len_ - pos_);
+absl::string_view QuicheDataReader::PeekRemainingPayload() const {
+ return absl::string_view(data_ + pos_, len_ - pos_);
}
-quiche::QuicheStringPiece QuicheDataReader::FullPayload() const {
- return quiche::QuicheStringPiece(data_, len_);
+absl::string_view QuicheDataReader::FullPayload() const {
+ return absl::string_view(data_, len_);
}
-quiche::QuicheStringPiece QuicheDataReader::PreviouslyReadPayload() const {
- return quiche::QuicheStringPiece(data_, pos_);
+absl::string_view QuicheDataReader::PreviouslyReadPayload() const {
+ return absl::string_view(data_, pos_);
}
bool QuicheDataReader::ReadBytes(void* result, size_t size) {
diff --git a/common/quiche_data_reader.h b/common/quiche_data_reader.h
index f74f90d..f3911c5 100644
--- a/common/quiche_data_reader.h
+++ b/common/quiche_data_reader.h
@@ -9,10 +9,10 @@
#include <cstdint>
#include <limits>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_logging.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quiche {
@@ -30,7 +30,7 @@
public:
// Constructs a reader using NETWORK_BYTE_ORDER endianness.
// Caller must provide an underlying buffer to work on.
- explicit QuicheDataReader(quiche::QuicheStringPiece data);
+ explicit QuicheDataReader(absl::string_view data);
// Constructs a reader using NETWORK_BYTE_ORDER endianness.
// Caller must provide an underlying buffer to work on.
QuicheDataReader(const char* data, const size_t len);
@@ -64,7 +64,7 @@
//
// Forwards the internal iterator on success.
// Returns true on success, false otherwise.
- bool ReadStringPiece16(quiche::QuicheStringPiece* result);
+ bool ReadStringPiece16(absl::string_view* result);
// Reads a string prefixed with 8-bit length into the given output parameter.
//
@@ -73,13 +73,13 @@
//
// Forwards the internal iterator on success.
// Returns true on success, false otherwise.
- bool ReadStringPiece8(quiche::QuicheStringPiece* result);
+ bool ReadStringPiece8(absl::string_view* result);
// Reads a given number of bytes into the given buffer. The buffer
// must be of adequate size.
// Forwards the internal iterator on success.
// Returns true on success, false otherwise.
- bool ReadStringPiece(quiche::QuicheStringPiece* result, size_t size);
+ bool ReadStringPiece(absl::string_view* result, size_t size);
// Reads tag represented as 32-bit unsigned integer into given output
// parameter. Tags are in big endian on the wire (e.g., CHLO is
@@ -92,38 +92,38 @@
// iterator on success, may forward it even in case of failure.
bool ReadDecimal64(size_t num_digits, uint64_t* result);
- // Returns the remaining payload as a quiche::QuicheStringPiece.
+ // Returns the remaining payload as a absl::string_view.
//
// NOTE: Does not copy but rather references strings in the underlying buffer.
// This should be kept in mind when handling memory management!
//
// Forwards the internal iterator.
- quiche::QuicheStringPiece ReadRemainingPayload();
+ absl::string_view ReadRemainingPayload();
- // Returns the remaining payload as a quiche::QuicheStringPiece.
+ // Returns the remaining payload as a absl::string_view.
//
// NOTE: Does not copy but rather references strings in the underlying buffer.
// This should be kept in mind when handling memory management!
//
// DOES NOT forward the internal iterator.
- quiche::QuicheStringPiece PeekRemainingPayload() const;
+ absl::string_view PeekRemainingPayload() const;
- // Returns the entire payload as a quiche::QuicheStringPiece.
+ // Returns the entire payload as a absl::string_view.
//
// NOTE: Does not copy but rather references strings in the underlying buffer.
// This should be kept in mind when handling memory management!
//
// DOES NOT forward the internal iterator.
- quiche::QuicheStringPiece FullPayload() const;
+ absl::string_view FullPayload() const;
// Returns the part of the payload that has been already read as a
- // quiche::QuicheStringPiece.
+ // absl::string_view.
//
// NOTE: Does not copy but rather references strings in the underlying buffer.
// This should be kept in mind when handling memory management!
//
// DOES NOT forward the internal iterator.
- quiche::QuicheStringPiece PreviouslyReadPayload() const;
+ absl::string_view PreviouslyReadPayload() const;
// Reads a given number of bytes into the given buffer. The buffer
// must be of adequate size.
diff --git a/common/quiche_data_writer.cc b/common/quiche_data_writer.cc
index 4488f72..d24a594 100644
--- a/common/quiche_data_writer.cc
+++ b/common/quiche_data_writer.cc
@@ -7,9 +7,9 @@
#include <algorithm>
#include <limits>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quiche {
@@ -65,7 +65,7 @@
num_bytes);
}
-bool QuicheDataWriter::WriteStringPiece16(quiche::QuicheStringPiece val) {
+bool QuicheDataWriter::WriteStringPiece16(absl::string_view val) {
if (val.size() > std::numeric_limits<uint16_t>::max()) {
return false;
}
@@ -75,7 +75,7 @@
return WriteBytes(val.data(), val.size());
}
-bool QuicheDataWriter::WriteStringPiece(quiche::QuicheStringPiece val) {
+bool QuicheDataWriter::WriteStringPiece(absl::string_view val) {
return WriteBytes(val.data(), val.size());
}
diff --git a/common/quiche_data_writer.h b/common/quiche_data_writer.h
index cded0fa..150657e 100644
--- a/common/quiche_data_writer.h
+++ b/common/quiche_data_writer.h
@@ -10,10 +10,10 @@
#include <cstring>
#include <limits>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_logging.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quiche {
@@ -54,8 +54,8 @@
// correct byte order.
bool WriteBytesToUInt64(size_t num_bytes, uint64_t value);
- bool WriteStringPiece(quiche::QuicheStringPiece val);
- bool WriteStringPiece16(quiche::QuicheStringPiece val);
+ bool WriteStringPiece(absl::string_view val);
+ bool WriteStringPiece16(absl::string_view val);
bool WriteBytes(const void* data, size_t data_len);
bool WriteRepeatedByte(uint8_t byte, size_t count);
// Fills the remaining buffer with null characters.
diff --git a/common/quiche_data_writer_test.cc b/common/quiche_data_writer_test.cc
index 343e6ea..72ce2c9 100644
--- a/common/quiche_data_writer_test.cc
+++ b/common/quiche_data_writer_test.cc
@@ -7,10 +7,10 @@
#include <cstdint>
#include <cstring>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_test.h"
#include "net/third_party/quiche/src/common/quiche_data_reader.h"
#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
@@ -386,43 +386,38 @@
char expected_first_read[4] = {1, 2, 3, 4};
char expected_remaining[12] = {5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
QuicheDataReader reader(buffer, sizeof(buffer));
- quiche::QuicheStringPiece previously_read_payload1 =
- reader.PreviouslyReadPayload();
+ absl::string_view previously_read_payload1 = reader.PreviouslyReadPayload();
EXPECT_TRUE(previously_read_payload1.empty());
char first_read_buffer[4] = {};
EXPECT_TRUE(reader.ReadBytes(first_read_buffer, sizeof(first_read_buffer)));
test::CompareCharArraysWithHexError(
"first read", first_read_buffer, sizeof(first_read_buffer),
expected_first_read, sizeof(expected_first_read));
- quiche::QuicheStringPiece peeked_remaining_payload =
- reader.PeekRemainingPayload();
+ absl::string_view peeked_remaining_payload = reader.PeekRemainingPayload();
test::CompareCharArraysWithHexError(
"peeked_remaining_payload", peeked_remaining_payload.data(),
peeked_remaining_payload.length(), expected_remaining,
sizeof(expected_remaining));
- quiche::QuicheStringPiece full_payload = reader.FullPayload();
+ absl::string_view full_payload = reader.FullPayload();
test::CompareCharArraysWithHexError("full_payload", full_payload.data(),
full_payload.length(), buffer,
sizeof(buffer));
- quiche::QuicheStringPiece previously_read_payload2 =
- reader.PreviouslyReadPayload();
+ absl::string_view previously_read_payload2 = reader.PreviouslyReadPayload();
test::CompareCharArraysWithHexError(
"previously_read_payload2", previously_read_payload2.data(),
previously_read_payload2.length(), first_read_buffer,
sizeof(first_read_buffer));
- quiche::QuicheStringPiece read_remaining_payload =
- reader.ReadRemainingPayload();
+ absl::string_view read_remaining_payload = reader.ReadRemainingPayload();
test::CompareCharArraysWithHexError(
"read_remaining_payload", read_remaining_payload.data(),
read_remaining_payload.length(), expected_remaining,
sizeof(expected_remaining));
EXPECT_TRUE(reader.IsDoneReading());
- quiche::QuicheStringPiece full_payload2 = reader.FullPayload();
+ absl::string_view full_payload2 = reader.FullPayload();
test::CompareCharArraysWithHexError("full_payload2", full_payload2.data(),
full_payload2.length(), buffer,
sizeof(buffer));
- quiche::QuicheStringPiece previously_read_payload3 =
- reader.PreviouslyReadPayload();
+ absl::string_view previously_read_payload3 = reader.PreviouslyReadPayload();
test::CompareCharArraysWithHexError(
"previously_read_payload3", previously_read_payload3.data(),
previously_read_payload3.length(), buffer, sizeof(buffer));
