Replace quiche::QuicheStringPiece with absl::string_view.
PiperOrigin-RevId: 336805352
Change-Id: I90543ee2730573441efea777ef67729792796902
diff --git a/spdy/core/hpack/hpack_decoder_adapter.cc b/spdy/core/hpack/hpack_decoder_adapter.cc
index cf9a0e7..fa54464 100644
--- a/spdy/core/hpack/hpack_decoder_adapter.cc
+++ b/spdy/core/hpack/hpack_decoder_adapter.cc
@@ -185,7 +185,7 @@
}
void HpackDecoderAdapter::ListenerAdapter::OnHeaderErrorDetected(
- quiche::QuicheStringPiece error_message) {
+ absl::string_view error_message) {
SPDY_VLOG(1) << error_message;
}
diff --git a/spdy/core/hpack/hpack_decoder_adapter.h b/spdy/core/hpack/hpack_decoder_adapter.h
index f521ee1..36f42b7 100644
--- a/spdy/core/hpack/hpack_decoder_adapter.h
+++ b/spdy/core/hpack/hpack_decoder_adapter.h
@@ -13,13 +13,13 @@
#include <cstdint>
#include <memory>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/http2/hpack/decoder/hpack_decoder.h"
#include "net/third_party/quiche/src/http2/hpack/decoder/hpack_decoder_listener.h"
#include "net/third_party/quiche/src/http2/hpack/decoder/hpack_decoder_tables.h"
#include "net/third_party/quiche/src/http2/hpack/hpack_string.h"
#include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.h"
#include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
#include "net/third_party/quiche/src/spdy/core/spdy_headers_handler_interface.h"
@@ -113,8 +113,7 @@
void OnHeader(const http2::HpackString& name,
const http2::HpackString& value) override;
void OnHeaderListEnd() override;
- void OnHeaderErrorDetected(
- quiche::QuicheStringPiece error_message) override;
+ void OnHeaderErrorDetected(absl::string_view error_message) override;
// Override the HpackDecoderTablesDebugListener methods:
int64_t OnEntryInserted(const http2::HpackStringPair& entry,
diff --git a/spdy/core/hpack/hpack_decoder_adapter_test.cc b/spdy/core/hpack/hpack_decoder_adapter_test.cc
index fb9bfbd..c1ed5d6 100644
--- a/spdy/core/hpack/hpack_decoder_adapter_test.cc
+++ b/spdy/core/hpack/hpack_decoder_adapter_test.cc
@@ -65,8 +65,8 @@
explicit HpackDecoderAdapterPeer(HpackDecoderAdapter* decoder)
: decoder_(decoder) {}
- void HandleHeaderRepresentation(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) {
+ void HandleHeaderRepresentation(absl::string_view name,
+ absl::string_view value) {
decoder_->listener_adapter_.OnHeader(HpackString(name), HpackString(value));
}
@@ -133,7 +133,7 @@
}
}
- bool HandleControlFrameHeadersData(quiche::QuicheStringPiece str) {
+ bool HandleControlFrameHeadersData(absl::string_view str) {
SPDY_VLOG(3) << "HandleControlFrameHeadersData:\n" << SpdyHexDump(str);
bytes_passed_in_ += str.size();
return decoder_.HandleControlFrameHeadersData(str.data(), str.size());
@@ -147,7 +147,7 @@
return rc;
}
- bool DecodeHeaderBlock(quiche::QuicheStringPiece str,
+ bool DecodeHeaderBlock(absl::string_view str,
bool check_decoded_size = true) {
// Don't call this again if HandleControlFrameHeadersData failed previously.
EXPECT_FALSE(decode_has_failed_);
@@ -225,8 +225,7 @@
return size;
}
- const SpdyHeaderBlock& DecodeBlockExpectingSuccess(
- quiche::QuicheStringPiece str) {
+ const SpdyHeaderBlock& DecodeBlockExpectingSuccess(absl::string_view str) {
EXPECT_TRUE(DecodeHeaderBlock(str));
return decoded_block();
}
@@ -434,11 +433,10 @@
decoded_block(),
ElementsAre(
Pair("cookie", " part 1; part 2 ; part3; fin!"),
- Pair("passed-through", quiche::QuicheStringPiece("foo\0baz", 7)),
- Pair("joined",
- quiche::QuicheStringPiece("joined\0value 1\0value 2", 22)),
+ Pair("passed-through", absl::string_view("foo\0baz", 7)),
+ Pair("joined", absl::string_view("joined\0value 1\0value 2", 22)),
Pair("empty", ""),
- Pair("empty-joined", quiche::QuicheStringPiece("\0foo\0\0", 6))));
+ Pair("empty-joined", absl::string_view("\0foo\0\0", 6))));
}
// Decoding indexed static table field should work.
@@ -503,7 +501,7 @@
output_stream.AppendUint32(126);
output_stream.TakeString(&input);
- EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
+ EXPECT_TRUE(DecodeHeaderBlock(absl::string_view(input)));
EXPECT_EQ(126u, decoder_peer_.header_table_size_limit());
}
{
@@ -513,7 +511,7 @@
output_stream.AppendUint32(kDefaultHeaderTableSizeSetting);
output_stream.TakeString(&input);
- EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
+ EXPECT_TRUE(DecodeHeaderBlock(absl::string_view(input)));
EXPECT_EQ(kDefaultHeaderTableSizeSetting,
decoder_peer_.header_table_size_limit());
}
@@ -524,7 +522,7 @@
output_stream.AppendUint32(kDefaultHeaderTableSizeSetting + 1);
output_stream.TakeString(&input);
- EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
+ EXPECT_FALSE(DecodeHeaderBlock(absl::string_view(input)));
EXPECT_EQ(kDefaultHeaderTableSizeSetting,
decoder_peer_.header_table_size_limit());
}
@@ -542,7 +540,7 @@
output_stream.AppendUint32(122);
output_stream.TakeString(&input);
- EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
+ EXPECT_TRUE(DecodeHeaderBlock(absl::string_view(input)));
EXPECT_EQ(122u, decoder_peer_.header_table_size_limit());
}
}
@@ -562,7 +560,7 @@
output_stream.TakeString(&input);
- EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
+ EXPECT_FALSE(DecodeHeaderBlock(absl::string_view(input)));
EXPECT_EQ(10u, decoder_peer_.header_table_size_limit());
}
}
@@ -581,7 +579,7 @@
output_stream.TakeString(&input);
- EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
+ EXPECT_FALSE(DecodeHeaderBlock(absl::string_view(input)));
EXPECT_EQ(kDefaultHeaderTableSizeSetting,
decoder_peer_.header_table_size_limit());
}
@@ -604,7 +602,7 @@
output_stream.TakeString(&input);
- EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
+ EXPECT_FALSE(DecodeHeaderBlock(absl::string_view(input)));
EXPECT_EQ(60u, decoder_peer_.header_table_size_limit());
}
}
@@ -616,7 +614,7 @@
// name.
const char input[] = "\x04\x0c/sample/path\x00\x06:path2\x0e/sample/path/2";
const SpdyHeaderBlock& header_set = DecodeBlockExpectingSuccess(
- quiche::QuicheStringPiece(input, QUICHE_ARRAYSIZE(input) - 1));
+ absl::string_view(input, QUICHE_ARRAYSIZE(input) - 1));
SpdyHeaderBlock expected_header_set;
expected_header_set[":path"] = "/sample/path";
@@ -629,7 +627,7 @@
TEST_P(HpackDecoderAdapterTest, LiteralHeaderIncrementalIndexing) {
const char input[] = "\x44\x0c/sample/path\x40\x06:path2\x0e/sample/path/2";
const SpdyHeaderBlock& header_set = DecodeBlockExpectingSuccess(
- quiche::QuicheStringPiece(input, QUICHE_ARRAYSIZE(input) - 1));
+ absl::string_view(input, QUICHE_ARRAYSIZE(input) - 1));
SpdyHeaderBlock expected_header_set;
expected_header_set[":path"] = "/sample/path";
@@ -642,23 +640,23 @@
EXPECT_TRUE(EncodeAndDecodeDynamicTableSizeUpdates(0, 0));
// Name is the last static index. Works.
- EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x7d\x03ooo")));
+ EXPECT_TRUE(DecodeHeaderBlock(absl::string_view("\x7d\x03ooo")));
// Name is one beyond the last static index. Fails.
- EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x7e\x03ooo")));
+ EXPECT_FALSE(DecodeHeaderBlock(absl::string_view("\x7e\x03ooo")));
}
TEST_P(HpackDecoderAdapterTest, LiteralHeaderNoIndexingInvalidNameIndex) {
// Name is the last static index. Works.
- EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x0f\x2e\x03ooo")));
+ EXPECT_TRUE(DecodeHeaderBlock(absl::string_view("\x0f\x2e\x03ooo")));
// Name is one beyond the last static index. Fails.
- EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x0f\x2f\x03ooo")));
+ EXPECT_FALSE(DecodeHeaderBlock(absl::string_view("\x0f\x2f\x03ooo")));
}
TEST_P(HpackDecoderAdapterTest, LiteralHeaderNeverIndexedInvalidNameIndex) {
// Name is the last static index. Works.
- EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x1f\x2e\x03ooo")));
+ EXPECT_TRUE(DecodeHeaderBlock(absl::string_view("\x1f\x2e\x03ooo")));
// Name is one beyond the last static index. Fails.
- EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x1f\x2f\x03ooo")));
+ EXPECT_FALSE(DecodeHeaderBlock(absl::string_view("\x1f\x2f\x03ooo")));
}
TEST_P(HpackDecoderAdapterTest, TruncatedIndex) {
@@ -1055,10 +1053,10 @@
hbb.AppendDynamicTableSizeUpdate(0);
hbb.AppendDynamicTableSizeUpdate(63);
- const quiche::QuicheStringPiece name("some-name");
- const quiche::QuicheStringPiece value1("some-value");
- const quiche::QuicheStringPiece value2("another-value");
- const quiche::QuicheStringPiece value3("yet-another-value");
+ const absl::string_view name("some-name");
+ const absl::string_view value1("some-value");
+ const absl::string_view value2("another-value");
+ const absl::string_view value3("yet-another-value");
// Add an entry that will become the first in the dynamic table, entry 62.
hbb.AppendLiteralNameAndValue(HpackEntryType::kIndexedLiteralHeader, false,
diff --git a/spdy/core/hpack/hpack_encoder.cc b/spdy/core/hpack/hpack_encoder.cc
index 566f4ee..6ad6a5f 100644
--- a/spdy/core/hpack/hpack_encoder.cc
+++ b/spdy/core/hpack/hpack_encoder.cc
@@ -58,12 +58,10 @@
namespace {
// The default header listener.
-void NoOpListener(quiche::QuicheStringPiece /*name*/,
- quiche::QuicheStringPiece /*value*/) {}
+void NoOpListener(absl::string_view /*name*/, absl::string_view /*value*/) {}
// The default HPACK indexing policy.
-bool DefaultPolicy(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece /* value */) {
+bool DefaultPolicy(absl::string_view name, absl::string_view /* value */) {
if (name.empty()) {
return false;
}
@@ -200,7 +198,7 @@
EmitString(representation.second);
}
-void HpackEncoder::EmitString(quiche::QuicheStringPiece str) {
+void HpackEncoder::EmitString(absl::string_view str) {
size_t encoded_size =
enable_compression_
? (use_fast_huffman_encoder_ ? http2::HuffmanSize(str)
@@ -249,21 +247,19 @@
// See Section 8.1.2.5. "Compressing the Cookie Header Field" in the HTTP/2
// specification at https://tools.ietf.org/html/draft-ietf-httpbis-http2-14.
// Cookie values are split into individually-encoded HPACK representations.
- quiche::QuicheStringPiece cookie_value = cookie.second;
+ absl::string_view cookie_value = cookie.second;
// Consume leading and trailing whitespace if present.
- quiche::QuicheStringPiece::size_type first =
- cookie_value.find_first_not_of(" \t");
- quiche::QuicheStringPiece::size_type last =
- cookie_value.find_last_not_of(" \t");
- if (first == quiche::QuicheStringPiece::npos) {
- cookie_value = quiche::QuicheStringPiece();
+ absl::string_view::size_type first = cookie_value.find_first_not_of(" \t");
+ absl::string_view::size_type last = cookie_value.find_last_not_of(" \t");
+ if (first == absl::string_view::npos) {
+ cookie_value = absl::string_view();
} else {
cookie_value = cookie_value.substr(first, (last - first) + 1);
}
for (size_t pos = 0;;) {
size_t end = cookie_value.find(";", pos);
- if (end == quiche::QuicheStringPiece::npos) {
+ if (end == absl::string_view::npos) {
out->push_back(std::make_pair(cookie.first, cookie_value.substr(pos)));
break;
}
@@ -283,12 +279,12 @@
Representations* out) {
size_t pos = 0;
size_t end = 0;
- while (end != quiche::QuicheStringPiece::npos) {
+ while (end != absl::string_view::npos) {
end = header_field.second.find('\0', pos);
out->push_back(std::make_pair(
header_field.first,
header_field.second.substr(
- pos, end == quiche::QuicheStringPiece::npos ? end : end - pos)));
+ pos, end == absl::string_view::npos ? end : end - pos)));
pos = end + 1;
}
}
diff --git a/spdy/core/hpack/hpack_encoder.h b/spdy/core/hpack/hpack_encoder.h
index 3b3e0d1..f9cc0d1 100644
--- a/spdy/core/hpack/hpack_encoder.h
+++ b/spdy/core/hpack/hpack_encoder.h
@@ -14,8 +14,8 @@
#include <utility>
#include <vector>
+#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_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.h"
#include "net/third_party/quiche/src/spdy/core/hpack/hpack_output_stream.h"
#include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
@@ -33,19 +33,18 @@
class QUICHE_EXPORT_PRIVATE HpackEncoder {
public:
- using Representation =
- std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>;
+ using Representation = std::pair<absl::string_view, absl::string_view>;
using Representations = std::vector<Representation>;
// Callers may provide a HeaderListener to be informed of header name-value
// pairs processed by this encoder.
using HeaderListener =
- std::function<void(quiche::QuicheStringPiece, quiche::QuicheStringPiece)>;
+ std::function<void(absl::string_view, absl::string_view)>;
// An indexing policy should return true if the provided header name-value
// pair should be inserted into the HPACK dynamic table.
using IndexingPolicy =
- std::function<bool(quiche::QuicheStringPiece, quiche::QuicheStringPiece)>;
+ std::function<bool(absl::string_view, absl::string_view)>;
HpackEncoder();
HpackEncoder(const HpackEncoder&) = delete;
@@ -125,7 +124,7 @@
void EmitLiteral(const Representation& representation);
// Emits a Huffman or identity string (whichever is smaller).
- void EmitString(quiche::QuicheStringPiece str);
+ void EmitString(absl::string_view str);
// Emits the current dynamic table size if the table size was recently
// updated and we have not yet emitted it (Section 6.3).
diff --git a/spdy/core/hpack/hpack_encoder_test.cc b/spdy/core/hpack/hpack_encoder_test.cc
index 62c7887..52693db 100644
--- a/spdy/core/hpack/hpack_encoder_test.cc
+++ b/spdy/core/hpack/hpack_encoder_test.cc
@@ -40,12 +40,12 @@
bool compression_enabled() const { return encoder_->enable_compression_; }
HpackHeaderTable* table() { return &encoder_->header_table_; }
HpackHeaderTablePeer table_peer() { return HpackHeaderTablePeer(table()); }
- void EmitString(quiche::QuicheStringPiece str) { encoder_->EmitString(str); }
+ void EmitString(absl::string_view str) { encoder_->EmitString(str); }
void TakeString(std::string* out) {
encoder_->output_stream_.TakeString(out);
}
- static void CookieToCrumbs(quiche::QuicheStringPiece cookie,
- std::vector<quiche::QuicheStringPiece>* out) {
+ static void CookieToCrumbs(absl::string_view cookie,
+ std::vector<absl::string_view>* out) {
Representations tmp;
HpackEncoder::CookieToCrumbs(std::make_pair("", cookie), &tmp);
@@ -54,9 +54,8 @@
out->push_back(tmp[i].second);
}
}
- static void DecomposeRepresentation(
- quiche::QuicheStringPiece value,
- std::vector<quiche::QuicheStringPiece>* out) {
+ static void DecomposeRepresentation(absl::string_view value,
+ std::vector<absl::string_view>* out) {
Representations tmp;
HpackEncoder::DecomposeRepresentation(std::make_pair("foobar", value),
&tmp);
@@ -150,12 +149,11 @@
peer_.table()->SetMaxSize(peer_.table()->size());
}
- void SaveHeaders(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) {
- quiche::QuicheStringPiece n(
- headers_storage_.Memdup(name.data(), name.size()), name.size());
- quiche::QuicheStringPiece v(
- headers_storage_.Memdup(value.data(), value.size()), value.size());
+ void SaveHeaders(absl::string_view name, absl::string_view value) {
+ absl::string_view n(headers_storage_.Memdup(name.data(), name.size()),
+ name.size());
+ absl::string_view v(headers_storage_.Memdup(value.data(), value.size()),
+ value.size());
headers_observed_.push_back(std::make_pair(n, v));
}
@@ -164,32 +162,31 @@
expected_.AppendUint32(index);
}
void ExpectIndexedLiteral(const HpackEntry* key_entry,
- quiche::QuicheStringPiece value) {
+ absl::string_view value) {
expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
expected_.AppendUint32(IndexOf(key_entry));
ExpectString(&expected_, value);
}
- void ExpectIndexedLiteral(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) {
+ void ExpectIndexedLiteral(absl::string_view name, absl::string_view value) {
expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
expected_.AppendUint32(0);
ExpectString(&expected_, name);
ExpectString(&expected_, value);
}
- void ExpectNonIndexedLiteral(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) {
+ void ExpectNonIndexedLiteral(absl::string_view name,
+ absl::string_view value) {
expected_.AppendPrefix(kLiteralNoIndexOpcode);
expected_.AppendUint32(0);
ExpectString(&expected_, name);
ExpectString(&expected_, value);
}
void ExpectNonIndexedLiteralWithNameIndex(const HpackEntry* key_entry,
- quiche::QuicheStringPiece value) {
+ absl::string_view value) {
expected_.AppendPrefix(kLiteralNoIndexOpcode);
expected_.AppendUint32(IndexOf(key_entry));
ExpectString(&expected_, value);
}
- void ExpectString(HpackOutputStream* stream, quiche::QuicheStringPiece str) {
+ void ExpectString(HpackOutputStream* stream, absl::string_view str) {
const HpackHuffmanTable& huffman_table = ObtainHpackHuffmanTable();
size_t encoded_size =
peer_.compression_enabled()
@@ -261,7 +258,7 @@
const HpackEntry* cookie_c_;
SpdySimpleArena headers_storage_;
- std::vector<std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>>
+ std::vector<std::pair<absl::string_view, absl::string_view>>
headers_observed_;
HpackOutputStream expected_;
@@ -278,16 +275,15 @@
TEST_P(HpackEncoderTestWithDefaultStrategy, EncodeRepresentations) {
encoder_.SetHeaderListener(
- [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
+ [this](absl::string_view name, absl::string_view value) {
this->SaveHeaders(name, value);
});
- const std::vector<
- std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>>
+ const std::vector<std::pair<absl::string_view, absl::string_view>>
header_list = {{"cookie", "val1; val2;val3"},
{":path", "/home"},
{"accept", "text/html, text/plain,application/xml"},
{"cookie", "val4"},
- {"withnul", quiche::QuicheStringPiece("one\0two", 7)}};
+ {"withnul", absl::string_view("one\0two", 7)}};
ExpectNonIndexedLiteralWithNameIndex(peer_.table()->GetByName(":path"),
"/home");
ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "val1");
@@ -296,7 +292,7 @@
ExpectIndexedLiteral(peer_.table()->GetByName("accept"),
"text/html, text/plain,application/xml");
ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "val4");
- ExpectIndexedLiteral("withnul", quiche::QuicheStringPiece("one\0two", 7));
+ ExpectIndexedLiteral("withnul", absl::string_view("one\0two", 7));
CompareWithExpectedEncoding(header_list);
EXPECT_THAT(
@@ -305,7 +301,7 @@
Pair("cookie", "val2"), Pair("cookie", "val3"),
Pair("accept", "text/html, text/plain,application/xml"),
Pair("cookie", "val4"),
- Pair("withnul", quiche::QuicheStringPiece("one\0two", 7))));
+ Pair("withnul", absl::string_view("one\0two", 7))));
}
INSTANTIATE_TEST_SUITE_P(HpackEncoderTests,
@@ -317,7 +313,7 @@
TEST_P(HpackEncoderTest, SingleDynamicIndex) {
encoder_.SetHeaderListener(
- [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
+ [this](absl::string_view name, absl::string_view value) {
this->SaveHeaders(name, value);
});
@@ -438,7 +434,7 @@
TEST_P(HpackEncoderTest, EncodingWithoutCompression) {
encoder_.SetHeaderListener(
- [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
+ [this](absl::string_view name, absl::string_view value) {
this->SaveHeaders(name, value);
});
encoder_.DisableCompression();
@@ -466,11 +462,10 @@
if (strategy_ == kRepresentations) {
EXPECT_THAT(
headers_observed_,
- ElementsAre(
- Pair(":path", "/index.html"), Pair("cookie", "foo=bar"),
- Pair("cookie", "baz=bing"),
- Pair("hello", quiche::QuicheStringPiece("goodbye\0aloha", 13)),
- Pair("multivalue", "value1, value2")));
+ ElementsAre(Pair(":path", "/index.html"), Pair("cookie", "foo=bar"),
+ Pair("cookie", "baz=bing"),
+ Pair("hello", absl::string_view("goodbye\0aloha", 13)),
+ Pair("multivalue", "value1, value2")));
} else {
EXPECT_THAT(
headers_observed_,
@@ -483,7 +478,7 @@
TEST_P(HpackEncoderTest, MultipleEncodingPasses) {
encoder_.SetHeaderListener(
- [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
+ [this](absl::string_view name, absl::string_view value) {
this->SaveHeaders(name, value);
});
@@ -580,7 +575,7 @@
TEST_P(HpackEncoderTest, CookieToCrumbs) {
test::HpackEncoderPeer peer(nullptr);
- std::vector<quiche::QuicheStringPiece> out;
+ std::vector<absl::string_view> out;
// Leading and trailing whitespace is consumed. A space after ';' is consumed.
// All other spaces remain. ';' at beginning and end of string produce empty
@@ -614,7 +609,7 @@
TEST_P(HpackEncoderTest, DecomposeRepresentation) {
test::HpackEncoderPeer peer(nullptr);
- std::vector<quiche::QuicheStringPiece> out;
+ std::vector<absl::string_view> out;
peer.DecomposeRepresentation("", &out);
EXPECT_THAT(out, ElementsAre(""));
@@ -622,19 +617,16 @@
peer.DecomposeRepresentation("foobar", &out);
EXPECT_THAT(out, ElementsAre("foobar"));
- peer.DecomposeRepresentation(quiche::QuicheStringPiece("foo\0bar", 7), &out);
+ peer.DecomposeRepresentation(absl::string_view("foo\0bar", 7), &out);
EXPECT_THAT(out, ElementsAre("foo", "bar"));
- peer.DecomposeRepresentation(quiche::QuicheStringPiece("\0foo\0bar", 8),
- &out);
+ peer.DecomposeRepresentation(absl::string_view("\0foo\0bar", 8), &out);
EXPECT_THAT(out, ElementsAre("", "foo", "bar"));
- peer.DecomposeRepresentation(quiche::QuicheStringPiece("foo\0bar\0", 8),
- &out);
+ peer.DecomposeRepresentation(absl::string_view("foo\0bar\0", 8), &out);
EXPECT_THAT(out, ElementsAre("foo", "bar", ""));
- peer.DecomposeRepresentation(quiche::QuicheStringPiece("\0foo\0bar\0", 9),
- &out);
+ peer.DecomposeRepresentation(absl::string_view("\0foo\0bar\0", 9), &out);
EXPECT_THAT(out, ElementsAre("", "foo", "bar", ""));
}
diff --git a/spdy/core/hpack/hpack_entry.cc b/spdy/core/hpack/hpack_entry.cc
index 586f321..7f251e6 100644
--- a/spdy/core/hpack/hpack_entry.cc
+++ b/spdy/core/hpack/hpack_entry.cc
@@ -12,8 +12,8 @@
const size_t HpackEntry::kSizeOverhead = 32;
-HpackEntry::HpackEntry(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value,
+HpackEntry::HpackEntry(absl::string_view name,
+ absl::string_view value,
bool is_static,
size_t insertion_index)
: name_(name.data(), name.size()),
@@ -24,8 +24,7 @@
type_(is_static ? STATIC : DYNAMIC),
time_added_(0) {}
-HpackEntry::HpackEntry(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value)
+HpackEntry::HpackEntry(absl::string_view name, absl::string_view value)
: name_ref_(name),
value_ref_(value),
insertion_index_(0),
@@ -44,8 +43,8 @@
} else {
name_ = other.name_;
value_ = other.value_;
- name_ref_ = quiche::QuicheStringPiece(name_.data(), name_.size());
- value_ref_ = quiche::QuicheStringPiece(value_.data(), value_.size());
+ name_ref_ = absl::string_view(name_.data(), name_.size());
+ value_ref_ = absl::string_view(value_.data(), value_.size());
}
}
@@ -61,16 +60,15 @@
}
name_ = other.name_;
value_ = other.value_;
- name_ref_ = quiche::QuicheStringPiece(name_.data(), name_.size());
- value_ref_ = quiche::QuicheStringPiece(value_.data(), value_.size());
+ name_ref_ = absl::string_view(name_.data(), name_.size());
+ value_ref_ = absl::string_view(value_.data(), value_.size());
return *this;
}
HpackEntry::~HpackEntry() = default;
// static
-size_t HpackEntry::Size(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) {
+size_t HpackEntry::Size(absl::string_view name, absl::string_view value) {
return name.size() + value.size() + kSizeOverhead;
}
size_t HpackEntry::Size() const {
diff --git a/spdy/core/hpack/hpack_entry.h b/spdy/core/hpack/hpack_entry.h
index 750c7e6..e9c4efc 100644
--- a/spdy/core/hpack/hpack_entry.h
+++ b/spdy/core/hpack/hpack_entry.h
@@ -9,8 +9,8 @@
#include <cstdint>
#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_string_piece.h"
// All section references below are to
// http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-08
@@ -34,15 +34,15 @@
// The combination of |is_static| and |insertion_index| allows an
// HpackEntryTable to determine the index of an HpackEntry in O(1) time.
// Copies |name| and |value|.
- HpackEntry(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value,
+ HpackEntry(absl::string_view name,
+ absl::string_view value,
bool is_static,
size_t insertion_index);
// Create a 'lookup' entry (only) suitable for querying a HpackEntrySet. The
// instance InsertionIndex() always returns 0 and IsLookup() returns true.
// The memory backing |name| and |value| must outlive this object.
- HpackEntry(quiche::QuicheStringPiece name, quiche::QuicheStringPiece value);
+ HpackEntry(absl::string_view name, absl::string_view value);
HpackEntry(const HpackEntry& other);
HpackEntry& operator=(const HpackEntry& other);
@@ -53,8 +53,8 @@
~HpackEntry();
- quiche::QuicheStringPiece name() const { return name_ref_; }
- quiche::QuicheStringPiece value() const { return value_ref_; }
+ absl::string_view name() const { return name_ref_; }
+ absl::string_view value() const { return value_ref_; }
// Returns whether this entry is a member of the static (as opposed to
// dynamic) table.
@@ -67,8 +67,7 @@
size_t InsertionIndex() const { return insertion_index_; }
// Returns the size of an entry as defined in 5.1.
- static size_t Size(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value);
+ static size_t Size(absl::string_view name, absl::string_view value);
size_t Size() const;
std::string GetDebugString() const;
@@ -92,8 +91,8 @@
// These members are always valid. For DYNAMIC and STATIC entries, they
// always point to |name_| and |value_|.
- quiche::QuicheStringPiece name_ref_;
- quiche::QuicheStringPiece value_ref_;
+ absl::string_view name_ref_;
+ absl::string_view value_ref_;
// The entry's index in the total set of entries ever inserted into the header
// table.
diff --git a/spdy/core/hpack/hpack_header_table.cc b/spdy/core/hpack/hpack_header_table.cc
index 67a0a5f..1ecfd79 100644
--- a/spdy/core/hpack/hpack_header_table.cc
+++ b/spdy/core/hpack/hpack_header_table.cc
@@ -60,7 +60,7 @@
return nullptr;
}
-const HpackEntry* HpackHeaderTable::GetByName(quiche::QuicheStringPiece name) {
+const HpackEntry* HpackHeaderTable::GetByName(absl::string_view name) {
{
auto it = static_name_index_.find(name);
if (it != static_name_index_.end()) {
@@ -80,9 +80,8 @@
return nullptr;
}
-const HpackEntry* HpackHeaderTable::GetByNameAndValue(
- quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) {
+const HpackEntry* HpackHeaderTable::GetByNameAndValue(absl::string_view name,
+ absl::string_view value) {
HpackEntry query(name, value);
{
auto it = static_index_.find(&query);
@@ -128,8 +127,8 @@
SetMaxSize(settings_size_bound_);
}
-void HpackHeaderTable::EvictionSet(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value,
+void HpackHeaderTable::EvictionSet(absl::string_view name,
+ absl::string_view value,
EntryTable::iterator* begin_out,
EntryTable::iterator* end_out) {
size_t eviction_count = EvictionCountForEntry(name, value);
@@ -137,9 +136,8 @@
*end_out = dynamic_entries_.end();
}
-size_t HpackHeaderTable::EvictionCountForEntry(
- quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) const {
+size_t HpackHeaderTable::EvictionCountForEntry(absl::string_view name,
+ absl::string_view value) const {
size_t available_size = max_size_ - size_;
size_t entry_size = HpackEntry::Size(name, value);
@@ -185,9 +183,8 @@
}
}
-const HpackEntry* HpackHeaderTable::TryAddEntry(
- quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) {
+const HpackEntry* HpackHeaderTable::TryAddEntry(absl::string_view name,
+ absl::string_view value) {
Evict(EvictionCountForEntry(name, value));
size_t entry_size = HpackEntry::Size(name, value);
diff --git a/spdy/core/hpack/hpack_header_table.h b/spdy/core/hpack/hpack_header_table.h
index 88ef6d7..7f558bd 100644
--- a/spdy/core/hpack/hpack_header_table.h
+++ b/spdy/core/hpack/hpack_header_table.h
@@ -10,6 +10,7 @@
#include <deque>
#include <memory>
+#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_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/hpack/hpack_entry.h"
@@ -67,7 +68,7 @@
bool operator()(const HpackEntry* lhs, const HpackEntry* rhs) const;
};
using UnorderedEntrySet = SpdyHashSet<HpackEntry*, EntryHasher, EntriesEq>;
- using NameToEntryMap = SpdyHashMap<quiche::QuicheStringPiece,
+ using NameToEntryMap = SpdyHashMap<absl::string_view,
const HpackEntry*,
quiche::QuicheStringPieceHash>;
@@ -89,11 +90,11 @@
const HpackEntry* GetByIndex(size_t index);
// Returns the lowest-value entry having |name|, or NULL.
- const HpackEntry* GetByName(quiche::QuicheStringPiece name);
+ const HpackEntry* GetByName(absl::string_view name);
// Returns the lowest-index matching entry, or NULL.
- const HpackEntry* GetByNameAndValue(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value);
+ const HpackEntry* GetByNameAndValue(absl::string_view name,
+ absl::string_view value);
// Returns the index of an entry within this header table.
size_t IndexOf(const HpackEntry* entry) const;
@@ -109,8 +110,8 @@
// Determine the set of entries which would be evicted by the insertion
// of |name| & |value| into the table, as per section 4.4. No eviction
// actually occurs. The set is returned via range [begin_out, end_out).
- void EvictionSet(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value,
+ void EvictionSet(absl::string_view name,
+ absl::string_view value,
EntryTable::iterator* begin_out,
EntryTable::iterator* end_out);
@@ -118,8 +119,8 @@
// and |value| must not be owned by an entry which could be evicted. The
// added HpackEntry is returned, or NULL is returned if all entries were
// evicted and the empty table is of insufficent size for the representation.
- const HpackEntry* TryAddEntry(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value);
+ const HpackEntry* TryAddEntry(absl::string_view name,
+ absl::string_view value);
void DebugLogTableState() const SPDY_UNUSED;
@@ -132,8 +133,8 @@
private:
// Returns number of evictions required to enter |name| & |value|.
- size_t EvictionCountForEntry(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) const;
+ size_t EvictionCountForEntry(absl::string_view name,
+ absl::string_view value) const;
// Returns number of evictions required to reclaim |reclaim_size| table size.
size_t EvictionCountToReclaim(size_t reclaim_size) const;
diff --git a/spdy/core/hpack/hpack_header_table_test.cc b/spdy/core/hpack/hpack_header_table_test.cc
index cc5674f..0b6799e 100644
--- a/spdy/core/hpack/hpack_header_table_test.cc
+++ b/spdy/core/hpack/hpack_header_table_test.cc
@@ -33,8 +33,8 @@
size_t index_size() {
return table_->static_index_.size() + table_->dynamic_index_.size();
}
- std::vector<HpackEntry*> EvictionSet(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) {
+ std::vector<HpackEntry*> EvictionSet(absl::string_view name,
+ absl::string_view value) {
HpackHeaderTable::EntryTable::iterator begin, end;
table_->EvictionSet(name, value, &begin, &end);
std::vector<HpackEntry*> result;
@@ -45,8 +45,8 @@
}
size_t total_insertions() { return table_->total_insertions_; }
size_t dynamic_entries_count() { return table_->dynamic_entries_.size(); }
- size_t EvictionCountForEntry(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) {
+ size_t EvictionCountForEntry(absl::string_view name,
+ absl::string_view value) {
return table_->EvictionCountForEntry(name, value);
}
size_t EvictionCountToReclaim(size_t reclaim_size) {
@@ -54,8 +54,7 @@
}
void Evict(size_t count) { return table_->Evict(count); }
- void AddDynamicEntry(quiche::QuicheStringPiece name,
- quiche::QuicheStringPiece value) {
+ void AddDynamicEntry(absl::string_view name, absl::string_view value) {
table_->dynamic_entries_.push_back(
HpackEntry(name, value, false, table_->total_insertions_++));
}
diff --git a/spdy/core/hpack/hpack_huffman_table.cc b/spdy/core/hpack/hpack_huffman_table.cc
index eb799d0..aac6d1b 100644
--- a/spdy/core/hpack/hpack_huffman_table.cc
+++ b/spdy/core/hpack/hpack_huffman_table.cc
@@ -96,7 +96,7 @@
return !code_by_id_.empty();
}
-void HpackHuffmanTable::EncodeString(quiche::QuicheStringPiece in,
+void HpackHuffmanTable::EncodeString(absl::string_view in,
HpackOutputStream* out) const {
size_t bit_remnant = 0;
for (size_t i = 0; i != in.size(); i++) {
@@ -129,7 +129,7 @@
}
}
-size_t HpackHuffmanTable::EncodedSize(quiche::QuicheStringPiece in) const {
+size_t HpackHuffmanTable::EncodedSize(absl::string_view in) const {
size_t bit_count = 0;
for (size_t i = 0; i != in.size(); i++) {
uint16_t symbol_id = static_cast<uint8_t>(in[i]);
diff --git a/spdy/core/hpack/hpack_huffman_table.h b/spdy/core/hpack/hpack_huffman_table.h
index b7c2649..81af770 100644
--- a/spdy/core/hpack/hpack_huffman_table.h
+++ b/spdy/core/hpack/hpack_huffman_table.h
@@ -9,8 +9,8 @@
#include <cstdint>
#include <vector>
+#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_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/hpack/hpack_constants.h"
namespace spdy {
@@ -45,10 +45,10 @@
// Encodes the input string to the output stream using the table's Huffman
// context.
- void EncodeString(quiche::QuicheStringPiece in, HpackOutputStream* out) const;
+ void EncodeString(absl::string_view in, HpackOutputStream* out) const;
// Returns the encoded size of the input string.
- size_t EncodedSize(quiche::QuicheStringPiece in) const;
+ size_t EncodedSize(absl::string_view in) const;
// Returns the estimate of dynamically allocated memory in bytes.
size_t EstimateMemoryUsage() const;
diff --git a/spdy/core/hpack/hpack_huffman_table_test.cc b/spdy/core/hpack/hpack_huffman_table_test.cc
index f49c73d..b820f5e 100644
--- a/spdy/core/hpack/hpack_huffman_table_test.cc
+++ b/spdy/core/hpack/hpack_huffman_table_test.cc
@@ -42,7 +42,7 @@
protected:
GenericHuffmanTableTest() : table_(), peer_(table_) {}
- std::string EncodeString(quiche::QuicheStringPiece input) {
+ std::string EncodeString(absl::string_view input) {
std::string result;
HpackOutputStream output_stream;
table_.EncodeString(input, &output_stream);
@@ -171,12 +171,10 @@
EXPECT_EQ(0b10011000, peer_.pad_bits());
char input_storage[] = {2, 3, 2, 7, 4};
- quiche::QuicheStringPiece input(input_storage,
- QUICHE_ARRAYSIZE(input_storage));
+ absl::string_view input(input_storage, QUICHE_ARRAYSIZE(input_storage));
// By symbol: (2) 00 (3) 010 (2) 00 (7) 10010 (4) 10000 (6 as pad) 1001100.
char expect_storage[] = {0b00010001, 0b00101000, 0b01001100};
- quiche::QuicheStringPiece expect(expect_storage,
- QUICHE_ARRAYSIZE(expect_storage));
+ absl::string_view expect(expect_storage, QUICHE_ARRAYSIZE(expect_storage));
EXPECT_EQ(expect, EncodeString(input));
}
@@ -258,7 +256,7 @@
for (size_t i = 0; i != 256; i++) {
char c = static_cast<char>(i);
char storage[3] = {c, c, c};
- quiche::QuicheStringPiece input(storage, QUICHE_ARRAYSIZE(storage));
+ absl::string_view input(storage, QUICHE_ARRAYSIZE(storage));
std::string buffer_in = EncodeString(input);
std::string buffer_out;
DecodeString(buffer_in, &buffer_out);
@@ -272,7 +270,7 @@
storage[i] = static_cast<char>(i);
storage[511 - i] = static_cast<char>(i);
}
- quiche::QuicheStringPiece input(storage, QUICHE_ARRAYSIZE(storage));
+ absl::string_view input(storage, QUICHE_ARRAYSIZE(storage));
std::string buffer_in = EncodeString(input);
std::string buffer_out;
DecodeString(buffer_in, &buffer_out);
diff --git a/spdy/core/hpack/hpack_output_stream.cc b/spdy/core/hpack/hpack_output_stream.cc
index c53f07f..a532f0b 100644
--- a/spdy/core/hpack/hpack_output_stream.cc
+++ b/spdy/core/hpack/hpack_output_stream.cc
@@ -41,7 +41,7 @@
AppendBits(prefix.bits, prefix.bit_size);
}
-void HpackOutputStream::AppendBytes(quiche::QuicheStringPiece buffer) {
+void HpackOutputStream::AppendBytes(absl::string_view buffer) {
DCHECK_EQ(bit_offset_, 0u);
buffer_.append(buffer.data(), buffer.size());
}
diff --git a/spdy/core/hpack/hpack_output_stream.h b/spdy/core/hpack/hpack_output_stream.h
index f99097a..b94aa0c 100644
--- a/spdy/core/hpack/hpack_output_stream.h
+++ b/spdy/core/hpack/hpack_output_stream.h
@@ -9,8 +9,8 @@
#include <map>
#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_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/hpack/hpack_constants.h"
// All section references below are to
@@ -37,7 +37,7 @@
void AppendPrefix(HpackPrefix prefix);
// Directly appends |buffer|.
- void AppendBytes(quiche::QuicheStringPiece buffer);
+ void AppendBytes(absl::string_view buffer);
// Appends the given integer using the representation described in
// 6.1. If the internal buffer ends on a byte boundary, the prefix
diff --git a/spdy/core/hpack/hpack_static_table.cc b/spdy/core/hpack/hpack_static_table.cc
index e8b07f1..c0815ce 100644
--- a/spdy/core/hpack/hpack_static_table.cc
+++ b/spdy/core/hpack/hpack_static_table.cc
@@ -4,7 +4,7 @@
#include "net/third_party/quiche/src/spdy/core/hpack/hpack_static_table.h"
-#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/spdy/core/hpack/hpack_constants.h"
#include "net/third_party/quiche/src/spdy/core/hpack/hpack_entry.h"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_estimate_memory_usage.h"
@@ -24,8 +24,8 @@
for (const HpackStaticEntry* it = static_entry_table;
it != static_entry_table + static_entry_count; ++it) {
static_entries_.push_back(
- HpackEntry(quiche::QuicheStringPiece(it->name, it->name_len),
- quiche::QuicheStringPiece(it->value, it->value_len),
+ HpackEntry(absl::string_view(it->name, it->name_len),
+ absl::string_view(it->value, it->value_len),
true, // is_static
total_insertions));
HpackEntry* entry = &static_entries_.back();
diff --git a/spdy/core/hpack/hpack_static_table_test.cc b/spdy/core/hpack/hpack_static_table_test.cc
index 42c6254..36eb831 100644
--- a/spdy/core/hpack/hpack_static_table_test.cc
+++ b/spdy/core/hpack/hpack_static_table_test.cc
@@ -7,7 +7,7 @@
#include <set>
#include <vector>
-#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"
#include "net/third_party/quiche/src/spdy/core/hpack/hpack_constants.h"
@@ -39,7 +39,7 @@
HpackHeaderTable::NameToEntryMap static_name_index =
table_.GetStaticNameIndex();
- std::set<quiche::QuicheStringPiece> names;
+ std::set<absl::string_view> names;
for (auto* entry : static_index) {
names.insert(entry->name());
}
