Remove SpdyStringPiece; use QuicheStringPiece instead.
gfe-relnote: n/a, no functional change.
PiperOrigin-RevId: 288029999
Change-Id: If83322cadaac9647f246fa8ef18f5ce870995aa3
diff --git a/spdy/core/hpack/hpack_decoder_adapter.cc b/spdy/core/hpack/hpack_decoder_adapter.cc
index b3bce70..fd5a5be 100644
--- a/spdy/core/hpack/hpack_decoder_adapter.cc
+++ b/spdy/core/hpack/hpack_decoder_adapter.cc
@@ -171,7 +171,7 @@
}
void HpackDecoderAdapter::ListenerAdapter::OnHeaderErrorDetected(
- SpdyStringPiece error_message) {
+ quiche::QuicheStringPiece 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 cdea661..1d5c7b2 100644
--- a/spdy/core/hpack/hpack_decoder_adapter.h
+++ b/spdy/core/hpack/hpack_decoder_adapter.h
@@ -18,11 +18,11 @@
#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_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"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
namespace spdy {
namespace test {
@@ -108,7 +108,8 @@
void OnHeader(const http2::HpackString& name,
const http2::HpackString& value) override;
void OnHeaderListEnd() override;
- void OnHeaderErrorDetected(SpdyStringPiece error_message) override;
+ void OnHeaderErrorDetected(
+ quiche::QuicheStringPiece 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 88318fb..f1bfe0c 100644
--- a/spdy/core/hpack/hpack_decoder_adapter_test.cc
+++ b/spdy/core/hpack/hpack_decoder_adapter_test.cc
@@ -65,7 +65,8 @@
explicit HpackDecoderAdapterPeer(HpackDecoderAdapter* decoder)
: decoder_(decoder) {}
- void HandleHeaderRepresentation(SpdyStringPiece name, SpdyStringPiece value) {
+ void HandleHeaderRepresentation(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value) {
decoder_->listener_adapter_.OnHeader(HpackString(name), HpackString(value));
}
@@ -132,7 +133,7 @@
}
}
- bool HandleControlFrameHeadersData(SpdyStringPiece str) {
+ bool HandleControlFrameHeadersData(quiche::QuicheStringPiece str) {
SPDY_VLOG(3) << "HandleControlFrameHeadersData:\n" << SpdyHexDump(str);
bytes_passed_in_ += str.size();
return decoder_.HandleControlFrameHeadersData(str.data(), str.size());
@@ -146,7 +147,8 @@
return rc;
}
- bool DecodeHeaderBlock(SpdyStringPiece str, bool check_decoded_size = true) {
+ bool DecodeHeaderBlock(quiche::QuicheStringPiece str,
+ bool check_decoded_size = true) {
// Don't call this again if HandleControlFrameHeadersData failed previously.
EXPECT_FALSE(decode_has_failed_);
HandleControlFrameHeadersStart();
@@ -223,7 +225,8 @@
return size;
}
- const SpdyHeaderBlock& DecodeBlockExpectingSuccess(SpdyStringPiece str) {
+ const SpdyHeaderBlock& DecodeBlockExpectingSuccess(
+ quiche::QuicheStringPiece str) {
EXPECT_TRUE(DecodeHeaderBlock(str));
return decoded_block();
}
@@ -429,12 +432,13 @@
// Resulting decoded headers are in the same order as the inputs.
EXPECT_THAT(
decoded_block(),
- ElementsAre(Pair("cookie", " part 1; part 2 ; part3; fin!"),
- Pair("passed-through", SpdyStringPiece("foo\0baz", 7)),
- Pair("joined", "not joined"),
- Pair("joineD", SpdyStringPiece("value 1\0value 2", 15)),
- Pair("empty", ""),
- Pair("empty-joined", SpdyStringPiece("\0foo\0\0", 6))));
+ ElementsAre(
+ Pair("cookie", " part 1; part 2 ; part3; fin!"),
+ Pair("passed-through", quiche::QuicheStringPiece("foo\0baz", 7)),
+ Pair("joined", "not joined"),
+ Pair("joineD", quiche::QuicheStringPiece("value 1\0value 2", 15)),
+ Pair("empty", ""),
+ Pair("empty-joined", quiche::QuicheStringPiece("\0foo\0\0", 6))));
}
// Decoding indexed static table field should work.
@@ -499,7 +503,7 @@
output_stream.AppendUint32(126);
output_stream.TakeString(&input);
- EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece(input)));
+ EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
EXPECT_EQ(126u, decoder_peer_.header_table_size_limit());
}
{
@@ -509,7 +513,7 @@
output_stream.AppendUint32(kDefaultHeaderTableSizeSetting);
output_stream.TakeString(&input);
- EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece(input)));
+ EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
EXPECT_EQ(kDefaultHeaderTableSizeSetting,
decoder_peer_.header_table_size_limit());
}
@@ -520,7 +524,7 @@
output_stream.AppendUint32(kDefaultHeaderTableSizeSetting + 1);
output_stream.TakeString(&input);
- EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
+ EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
EXPECT_EQ(kDefaultHeaderTableSizeSetting,
decoder_peer_.header_table_size_limit());
}
@@ -538,7 +542,7 @@
output_stream.AppendUint32(122);
output_stream.TakeString(&input);
- EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece(input)));
+ EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
EXPECT_EQ(122u, decoder_peer_.header_table_size_limit());
}
}
@@ -558,7 +562,7 @@
output_stream.TakeString(&input);
- EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
+ EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
EXPECT_EQ(10u, decoder_peer_.header_table_size_limit());
}
}
@@ -577,7 +581,7 @@
output_stream.TakeString(&input);
- EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
+ EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
EXPECT_EQ(kDefaultHeaderTableSizeSetting,
decoder_peer_.header_table_size_limit());
}
@@ -600,7 +604,7 @@
output_stream.TakeString(&input);
- EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
+ EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
EXPECT_EQ(60u, decoder_peer_.header_table_size_limit());
}
}
@@ -612,7 +616,7 @@
// name.
const char input[] = "\x04\x0c/sample/path\x00\x06:path2\x0e/sample/path/2";
const SpdyHeaderBlock& header_set = DecodeBlockExpectingSuccess(
- SpdyStringPiece(input, QUICHE_ARRAYSIZE(input) - 1));
+ quiche::QuicheStringPiece(input, QUICHE_ARRAYSIZE(input) - 1));
SpdyHeaderBlock expected_header_set;
expected_header_set[":path"] = "/sample/path";
@@ -625,7 +629,7 @@
TEST_P(HpackDecoderAdapterTest, LiteralHeaderIncrementalIndexing) {
const char input[] = "\x44\x0c/sample/path\x40\x06:path2\x0e/sample/path/2";
const SpdyHeaderBlock& header_set = DecodeBlockExpectingSuccess(
- SpdyStringPiece(input, QUICHE_ARRAYSIZE(input) - 1));
+ quiche::QuicheStringPiece(input, QUICHE_ARRAYSIZE(input) - 1));
SpdyHeaderBlock expected_header_set;
expected_header_set[":path"] = "/sample/path";
@@ -638,23 +642,23 @@
EXPECT_TRUE(EncodeAndDecodeDynamicTableSizeUpdates(0, 0));
// Name is the last static index. Works.
- EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece("\x7d\x03ooo")));
+ EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x7d\x03ooo")));
// Name is one beyond the last static index. Fails.
- EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece("\x7e\x03ooo")));
+ EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x7e\x03ooo")));
}
TEST_P(HpackDecoderAdapterTest, LiteralHeaderNoIndexingInvalidNameIndex) {
// Name is the last static index. Works.
- EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece("\x0f\x2e\x03ooo")));
+ EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x0f\x2e\x03ooo")));
// Name is one beyond the last static index. Fails.
- EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece("\x0f\x2f\x03ooo")));
+ EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x0f\x2f\x03ooo")));
}
TEST_P(HpackDecoderAdapterTest, LiteralHeaderNeverIndexedInvalidNameIndex) {
// Name is the last static index. Works.
- EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece("\x1f\x2e\x03ooo")));
+ EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x1f\x2e\x03ooo")));
// Name is one beyond the last static index. Fails.
- EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece("\x1f\x2f\x03ooo")));
+ EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x1f\x2f\x03ooo")));
}
TEST_P(HpackDecoderAdapterTest, TruncatedIndex) {
@@ -1051,10 +1055,10 @@
hbb.AppendDynamicTableSizeUpdate(0);
hbb.AppendDynamicTableSizeUpdate(63);
- const SpdyStringPiece name("some-name");
- const SpdyStringPiece value1("some-value");
- const SpdyStringPiece value2("another-value");
- const SpdyStringPiece value3("yet-another-value");
+ 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");
// 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 368754e..3835047 100644
--- a/spdy/core/hpack/hpack_encoder.cc
+++ b/spdy/core/hpack/hpack_encoder.cc
@@ -56,10 +56,12 @@
namespace {
// The default header listener.
-void NoOpListener(SpdyStringPiece /*name*/, SpdyStringPiece /*value*/) {}
+void NoOpListener(quiche::QuicheStringPiece /*name*/,
+ quiche::QuicheStringPiece /*value*/) {}
// The default HPACK indexing policy.
-bool DefaultPolicy(SpdyStringPiece name, SpdyStringPiece /* value */) {
+bool DefaultPolicy(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece /* value */) {
if (name.empty()) {
return false;
}
@@ -188,7 +190,7 @@
EmitString(representation.second);
}
-void HpackEncoder::EmitString(SpdyStringPiece str) {
+void HpackEncoder::EmitString(quiche::QuicheStringPiece str) {
size_t encoded_size =
enable_compression_ ? huffman_table_.EncodedSize(str) : str.size();
if (encoded_size < str.size()) {
@@ -229,19 +231,21 @@
// 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.
- SpdyStringPiece cookie_value = cookie.second;
+ quiche::QuicheStringPiece cookie_value = cookie.second;
// Consume leading and trailing whitespace if present.
- SpdyStringPiece::size_type first = cookie_value.find_first_not_of(" \t");
- SpdyStringPiece::size_type last = cookie_value.find_last_not_of(" \t");
- if (first == SpdyStringPiece::npos) {
- cookie_value = SpdyStringPiece();
+ 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();
} else {
cookie_value = cookie_value.substr(first, (last - first) + 1);
}
for (size_t pos = 0;;) {
size_t end = cookie_value.find(";", pos);
- if (end == SpdyStringPiece::npos) {
+ if (end == quiche::QuicheStringPiece::npos) {
out->push_back(std::make_pair(cookie.first, cookie_value.substr(pos)));
break;
}
@@ -261,12 +265,12 @@
Representations* out) {
size_t pos = 0;
size_t end = 0;
- while (end != SpdyStringPiece::npos) {
+ while (end != quiche::QuicheStringPiece::npos) {
end = header_field.second.find('\0', pos);
out->push_back(std::make_pair(
header_field.first,
header_field.second.substr(
- pos, end == SpdyStringPiece::npos ? end : end - pos)));
+ pos, end == quiche::QuicheStringPiece::npos ? end : end - pos)));
pos = end + 1;
}
}
diff --git a/spdy/core/hpack/hpack_encoder.h b/spdy/core/hpack/hpack_encoder.h
index 03c9d92..115908b 100644
--- a/spdy/core/hpack/hpack_encoder.h
+++ b/spdy/core/hpack/hpack_encoder.h
@@ -14,11 +14,11 @@
#include <utility>
#include <vector>
+#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"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
// An HpackEncoder encodes header sets as outlined in
// http://tools.ietf.org/html/rfc7541.
@@ -33,16 +33,19 @@
class SPDY_EXPORT_PRIVATE HpackEncoder {
public:
- using Representation = std::pair<SpdyStringPiece, SpdyStringPiece>;
+ using Representation =
+ std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>;
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(SpdyStringPiece, SpdyStringPiece)>;
+ using HeaderListener =
+ std::function<void(quiche::QuicheStringPiece, quiche::QuicheStringPiece)>;
// 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(SpdyStringPiece, SpdyStringPiece)>;
+ using IndexingPolicy =
+ std::function<bool(quiche::QuicheStringPiece, quiche::QuicheStringPiece)>;
// |table| is an initialized HPACK Huffman table, having an
// externally-managed lifetime which spans beyond HpackEncoder.
@@ -123,7 +126,7 @@
void EmitLiteral(const Representation& representation);
// Emits a Huffman or identity string (whichever is smaller).
- void EmitString(SpdyStringPiece str);
+ void EmitString(quiche::QuicheStringPiece 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 b905214..a96ff69 100644
--- a/spdy/core/hpack/hpack_encoder_test.cc
+++ b/spdy/core/hpack/hpack_encoder_test.cc
@@ -41,12 +41,12 @@
const HpackHuffmanTable& huffman_table() const {
return encoder_->huffman_table_;
}
- void EmitString(SpdyStringPiece str) { encoder_->EmitString(str); }
+ void EmitString(quiche::QuicheStringPiece str) { encoder_->EmitString(str); }
void TakeString(std::string* out) {
encoder_->output_stream_.TakeString(out);
}
- static void CookieToCrumbs(SpdyStringPiece cookie,
- std::vector<SpdyStringPiece>* out) {
+ static void CookieToCrumbs(quiche::QuicheStringPiece cookie,
+ std::vector<quiche::QuicheStringPiece>* out) {
Representations tmp;
HpackEncoder::CookieToCrumbs(std::make_pair("", cookie), &tmp);
@@ -55,8 +55,9 @@
out->push_back(tmp[i].second);
}
}
- static void DecomposeRepresentation(SpdyStringPiece value,
- std::vector<SpdyStringPiece>* out) {
+ static void DecomposeRepresentation(
+ quiche::QuicheStringPiece value,
+ std::vector<quiche::QuicheStringPiece>* out) {
Representations tmp;
HpackEncoder::DecomposeRepresentation(std::make_pair("foobar", value),
&tmp);
@@ -148,11 +149,12 @@
peer_.table()->SetMaxSize(peer_.table()->size());
}
- void SaveHeaders(SpdyStringPiece name, SpdyStringPiece value) {
- SpdyStringPiece n(headers_storage_.Memdup(name.data(), name.size()),
- name.size());
- SpdyStringPiece v(headers_storage_.Memdup(value.data(), value.size()),
- value.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());
headers_observed_.push_back(std::make_pair(n, v));
}
@@ -161,24 +163,26 @@
expected_.AppendUint32(index);
}
void ExpectIndexedLiteral(const HpackEntry* key_entry,
- SpdyStringPiece value) {
+ quiche::QuicheStringPiece value) {
expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
expected_.AppendUint32(IndexOf(key_entry));
ExpectString(&expected_, value);
}
- void ExpectIndexedLiteral(SpdyStringPiece name, SpdyStringPiece value) {
+ void ExpectIndexedLiteral(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value) {
expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
expected_.AppendUint32(0);
ExpectString(&expected_, name);
ExpectString(&expected_, value);
}
- void ExpectNonIndexedLiteral(SpdyStringPiece name, SpdyStringPiece value) {
+ void ExpectNonIndexedLiteral(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value) {
expected_.AppendPrefix(kLiteralNoIndexOpcode);
expected_.AppendUint32(0);
ExpectString(&expected_, name);
ExpectString(&expected_, value);
}
- void ExpectString(HpackOutputStream* stream, SpdyStringPiece str) {
+ void ExpectString(HpackOutputStream* stream, quiche::QuicheStringPiece str) {
const HpackHuffmanTable& huffman_table = peer_.huffman_table();
size_t encoded_size = peer_.compression_enabled()
? huffman_table.EncodedSize(str)
@@ -244,7 +248,8 @@
const HpackEntry* cookie_c_;
SpdySimpleArena headers_storage_;
- std::vector<std::pair<SpdyStringPiece, SpdyStringPiece>> headers_observed_;
+ std::vector<std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>>
+ headers_observed_;
HpackOutputStream expected_;
EncodeStrategy strategy_ = kDefault;
@@ -252,15 +257,16 @@
TEST_F(HpackEncoderTestBase, EncodeRepresentations) {
encoder_.SetHeaderListener(
- [this](SpdyStringPiece name, SpdyStringPiece value) {
+ [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
this->SaveHeaders(name, value);
});
- const std::vector<std::pair<SpdyStringPiece, SpdyStringPiece>> header_list = {
- {"cookie", "val1; val2;val3"},
- {":path", "/home"},
- {"accept", "text/html, text/plain,application/xml"},
- {"cookie", "val4"},
- {"withnul", SpdyStringPiece("one\0two", 7)}};
+ const std::vector<
+ std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>>
+ header_list = {{"cookie", "val1; val2;val3"},
+ {":path", "/home"},
+ {"accept", "text/html, text/plain,application/xml"},
+ {"cookie", "val4"},
+ {"withnul", quiche::QuicheStringPiece("one\0two", 7)}};
ExpectNonIndexedLiteral(":path", "/home");
ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "val1");
ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "val2");
@@ -268,7 +274,7 @@
ExpectIndexedLiteral(peer_.table()->GetByName("accept"),
"text/html, text/plain,application/xml");
ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "val4");
- ExpectIndexedLiteral("withnul", SpdyStringPiece("one\0two", 7));
+ ExpectIndexedLiteral("withnul", quiche::QuicheStringPiece("one\0two", 7));
CompareWithExpectedEncoding(header_list);
EXPECT_THAT(
@@ -277,7 +283,7 @@
Pair("cookie", "val2"), Pair("cookie", "val3"),
Pair("accept", "text/html, text/plain,application/xml"),
Pair("cookie", "val4"),
- Pair("withnul", SpdyStringPiece("one\0two", 7))));
+ Pair("withnul", quiche::QuicheStringPiece("one\0two", 7))));
}
class HpackEncoderTest : public HpackEncoderTestBase,
@@ -297,7 +303,7 @@
TEST_P(HpackEncoderTest, SingleDynamicIndex) {
encoder_.SetHeaderListener(
- [this](SpdyStringPiece name, SpdyStringPiece value) {
+ [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
this->SaveHeaders(name, value);
});
@@ -418,7 +424,7 @@
TEST_P(HpackEncoderTest, EncodingWithoutCompression) {
encoder_.SetHeaderListener(
- [this](SpdyStringPiece name, SpdyStringPiece value) {
+ [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
this->SaveHeaders(name, value);
});
encoder_.DisableCompression();
@@ -446,10 +452,11 @@
if (strategy_ == kRepresentations) {
EXPECT_THAT(
headers_observed_,
- ElementsAre(Pair(":path", "/index.html"), Pair("cookie", "foo=bar"),
- Pair("cookie", "baz=bing"),
- Pair("hello", SpdyStringPiece("goodbye\0aloha", 13)),
- Pair("multivalue", "value1, value2")));
+ ElementsAre(
+ Pair(":path", "/index.html"), Pair("cookie", "foo=bar"),
+ Pair("cookie", "baz=bing"),
+ Pair("hello", quiche::QuicheStringPiece("goodbye\0aloha", 13)),
+ Pair("multivalue", "value1, value2")));
} else {
EXPECT_THAT(
headers_observed_,
@@ -462,7 +469,7 @@
TEST_P(HpackEncoderTest, MultipleEncodingPasses) {
encoder_.SetHeaderListener(
- [this](SpdyStringPiece name, SpdyStringPiece value) {
+ [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
this->SaveHeaders(name, value);
});
@@ -558,7 +565,7 @@
TEST_P(HpackEncoderTest, CookieToCrumbs) {
test::HpackEncoderPeer peer(nullptr);
- std::vector<SpdyStringPiece> out;
+ std::vector<quiche::QuicheStringPiece> out;
// Leading and trailing whitespace is consumed. A space after ';' is consumed.
// All other spaces remain. ';' at beginning and end of string produce empty
@@ -592,7 +599,7 @@
TEST_P(HpackEncoderTest, DecomposeRepresentation) {
test::HpackEncoderPeer peer(nullptr);
- std::vector<SpdyStringPiece> out;
+ std::vector<quiche::QuicheStringPiece> out;
peer.DecomposeRepresentation("", &out);
EXPECT_THAT(out, ElementsAre(""));
@@ -600,16 +607,19 @@
peer.DecomposeRepresentation("foobar", &out);
EXPECT_THAT(out, ElementsAre("foobar"));
- peer.DecomposeRepresentation(SpdyStringPiece("foo\0bar", 7), &out);
+ peer.DecomposeRepresentation(quiche::QuicheStringPiece("foo\0bar", 7), &out);
EXPECT_THAT(out, ElementsAre("foo", "bar"));
- peer.DecomposeRepresentation(SpdyStringPiece("\0foo\0bar", 8), &out);
+ peer.DecomposeRepresentation(quiche::QuicheStringPiece("\0foo\0bar", 8),
+ &out);
EXPECT_THAT(out, ElementsAre("", "foo", "bar"));
- peer.DecomposeRepresentation(SpdyStringPiece("foo\0bar\0", 8), &out);
+ peer.DecomposeRepresentation(quiche::QuicheStringPiece("foo\0bar\0", 8),
+ &out);
EXPECT_THAT(out, ElementsAre("foo", "bar", ""));
- peer.DecomposeRepresentation(SpdyStringPiece("\0foo\0bar\0", 9), &out);
+ peer.DecomposeRepresentation(quiche::QuicheStringPiece("\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 0965739..c96e35c 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(SpdyStringPiece name,
- SpdyStringPiece value,
+HpackEntry::HpackEntry(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value,
bool is_static,
size_t insertion_index)
: name_(name.data(), name.size()),
@@ -24,7 +24,8 @@
type_(is_static ? STATIC : DYNAMIC),
time_added_(0) {}
-HpackEntry::HpackEntry(SpdyStringPiece name, SpdyStringPiece value)
+HpackEntry::HpackEntry(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value)
: name_ref_(name),
value_ref_(value),
insertion_index_(0),
@@ -43,8 +44,8 @@
} else {
name_ = other.name_;
value_ = other.value_;
- name_ref_ = SpdyStringPiece(name_.data(), name_.size());
- value_ref_ = SpdyStringPiece(value_.data(), value_.size());
+ name_ref_ = quiche::QuicheStringPiece(name_.data(), name_.size());
+ value_ref_ = quiche::QuicheStringPiece(value_.data(), value_.size());
}
}
@@ -60,15 +61,16 @@
}
name_ = other.name_;
value_ = other.value_;
- name_ref_ = SpdyStringPiece(name_.data(), name_.size());
- value_ref_ = SpdyStringPiece(value_.data(), value_.size());
+ name_ref_ = quiche::QuicheStringPiece(name_.data(), name_.size());
+ value_ref_ = quiche::QuicheStringPiece(value_.data(), value_.size());
return *this;
}
HpackEntry::~HpackEntry() = default;
// static
-size_t HpackEntry::Size(SpdyStringPiece name, SpdyStringPiece value) {
+size_t HpackEntry::Size(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece 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 50ac3a7..d36bce4 100644
--- a/spdy/core/hpack/hpack_entry.h
+++ b/spdy/core/hpack/hpack_entry.h
@@ -9,8 +9,8 @@
#include <cstdint>
#include <string>
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_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(SpdyStringPiece name,
- SpdyStringPiece value,
+ HpackEntry(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece 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(SpdyStringPiece name, SpdyStringPiece value);
+ HpackEntry(quiche::QuicheStringPiece name, quiche::QuicheStringPiece value);
HpackEntry(const HpackEntry& other);
HpackEntry& operator=(const HpackEntry& other);
@@ -53,8 +53,8 @@
~HpackEntry();
- SpdyStringPiece name() const { return name_ref_; }
- SpdyStringPiece value() const { return value_ref_; }
+ quiche::QuicheStringPiece name() const { return name_ref_; }
+ quiche::QuicheStringPiece value() const { return value_ref_; }
// Returns whether this entry is a member of the static (as opposed to
// dynamic) table.
@@ -67,7 +67,8 @@
size_t InsertionIndex() const { return insertion_index_; }
// Returns the size of an entry as defined in 5.1.
- static size_t Size(SpdyStringPiece name, SpdyStringPiece value);
+ static size_t Size(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value);
size_t Size() const;
std::string GetDebugString() const;
@@ -91,8 +92,8 @@
// These members are always valid. For DYNAMIC and STATIC entries, they
// always point to |name_| and |value_|.
- SpdyStringPiece name_ref_;
- SpdyStringPiece value_ref_;
+ quiche::QuicheStringPiece name_ref_;
+ quiche::QuicheStringPiece 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 17f91cd..67a0a5f 100644
--- a/spdy/core/hpack/hpack_header_table.cc
+++ b/spdy/core/hpack/hpack_header_table.cc
@@ -16,7 +16,7 @@
size_t HpackHeaderTable::EntryHasher::operator()(
const HpackEntry* entry) const {
- return SpdyHashStringPair(entry->name(), entry->value());
+ return quiche::QuicheHashStringPair(entry->name(), entry->value());
}
bool HpackHeaderTable::EntriesEq::operator()(const HpackEntry* lhs,
@@ -60,7 +60,7 @@
return nullptr;
}
-const HpackEntry* HpackHeaderTable::GetByName(SpdyStringPiece name) {
+const HpackEntry* HpackHeaderTable::GetByName(quiche::QuicheStringPiece name) {
{
auto it = static_name_index_.find(name);
if (it != static_name_index_.end()) {
@@ -80,8 +80,9 @@
return nullptr;
}
-const HpackEntry* HpackHeaderTable::GetByNameAndValue(SpdyStringPiece name,
- SpdyStringPiece value) {
+const HpackEntry* HpackHeaderTable::GetByNameAndValue(
+ quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value) {
HpackEntry query(name, value);
{
auto it = static_index_.find(&query);
@@ -127,8 +128,8 @@
SetMaxSize(settings_size_bound_);
}
-void HpackHeaderTable::EvictionSet(SpdyStringPiece name,
- SpdyStringPiece value,
+void HpackHeaderTable::EvictionSet(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value,
EntryTable::iterator* begin_out,
EntryTable::iterator* end_out) {
size_t eviction_count = EvictionCountForEntry(name, value);
@@ -136,8 +137,9 @@
*end_out = dynamic_entries_.end();
}
-size_t HpackHeaderTable::EvictionCountForEntry(SpdyStringPiece name,
- SpdyStringPiece value) const {
+size_t HpackHeaderTable::EvictionCountForEntry(
+ quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value) const {
size_t available_size = max_size_ - size_;
size_t entry_size = HpackEntry::Size(name, value);
@@ -183,8 +185,9 @@
}
}
-const HpackEntry* HpackHeaderTable::TryAddEntry(SpdyStringPiece name,
- SpdyStringPiece value) {
+const HpackEntry* HpackHeaderTable::TryAddEntry(
+ quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece 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 7ff49f3..3f532ac 100644
--- a/spdy/core/hpack/hpack_header_table.h
+++ b/spdy/core/hpack/hpack_header_table.h
@@ -10,11 +10,11 @@
#include <deque>
#include <memory>
+#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"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_containers.h"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_macros.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
// All section references below are to http://tools.ietf.org/html/rfc7541.
@@ -67,8 +67,9 @@
bool operator()(const HpackEntry* lhs, const HpackEntry* rhs) const;
};
using UnorderedEntrySet = SpdyHashSet<HpackEntry*, EntryHasher, EntriesEq>;
- using NameToEntryMap =
- SpdyHashMap<SpdyStringPiece, const HpackEntry*, SpdyStringPieceHash>;
+ using NameToEntryMap = SpdyHashMap<quiche::QuicheStringPiece,
+ const HpackEntry*,
+ quiche::QuicheStringPieceHash>;
HpackHeaderTable();
HpackHeaderTable(const HpackHeaderTable&) = delete;
@@ -88,11 +89,11 @@
const HpackEntry* GetByIndex(size_t index);
// Returns the lowest-value entry having |name|, or NULL.
- const HpackEntry* GetByName(SpdyStringPiece name);
+ const HpackEntry* GetByName(quiche::QuicheStringPiece name);
// Returns the lowest-index matching entry, or NULL.
- const HpackEntry* GetByNameAndValue(SpdyStringPiece name,
- SpdyStringPiece value);
+ const HpackEntry* GetByNameAndValue(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value);
// Returns the index of an entry within this header table.
size_t IndexOf(const HpackEntry* entry) const;
@@ -108,8 +109,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(SpdyStringPiece name,
- SpdyStringPiece value,
+ void EvictionSet(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value,
EntryTable::iterator* begin_out,
EntryTable::iterator* end_out);
@@ -117,7 +118,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(SpdyStringPiece name, SpdyStringPiece value);
+ const HpackEntry* TryAddEntry(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value);
void DebugLogTableState() const SPDY_UNUSED;
@@ -130,8 +132,8 @@
private:
// Returns number of evictions required to enter |name| & |value|.
- size_t EvictionCountForEntry(SpdyStringPiece name,
- SpdyStringPiece value) const;
+ size_t EvictionCountForEntry(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece 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 a7d2482..4f77587 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(SpdyStringPiece name,
- SpdyStringPiece value) {
+ std::vector<HpackEntry*> EvictionSet(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value) {
HpackHeaderTable::EntryTable::iterator begin, end;
table_->EvictionSet(name, value, &begin, &end);
std::vector<HpackEntry*> result;
@@ -45,7 +45,8 @@
}
size_t total_insertions() { return table_->total_insertions_; }
size_t dynamic_entries_count() { return table_->dynamic_entries_.size(); }
- size_t EvictionCountForEntry(SpdyStringPiece name, SpdyStringPiece value) {
+ size_t EvictionCountForEntry(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value) {
return table_->EvictionCountForEntry(name, value);
}
size_t EvictionCountToReclaim(size_t reclaim_size) {
@@ -53,7 +54,8 @@
}
void Evict(size_t count) { return table_->Evict(count); }
- void AddDynamicEntry(SpdyStringPiece name, SpdyStringPiece value) {
+ void AddDynamicEntry(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece 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 3c637a4..eb799d0 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(SpdyStringPiece in,
+void HpackHuffmanTable::EncodeString(quiche::QuicheStringPiece 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(SpdyStringPiece in) const {
+size_t HpackHuffmanTable::EncodedSize(quiche::QuicheStringPiece 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 a01c62f..abf8caa 100644
--- a/spdy/core/hpack/hpack_huffman_table.h
+++ b/spdy/core/hpack/hpack_huffman_table.h
@@ -9,9 +9,9 @@
#include <cstdint>
#include <vector>
+#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"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
namespace spdy {
@@ -45,10 +45,10 @@
// Encodes the input string to the output stream using the table's Huffman
// context.
- void EncodeString(SpdyStringPiece in, HpackOutputStream* out) const;
+ void EncodeString(quiche::QuicheStringPiece in, HpackOutputStream* out) const;
// Returns the encoded size of the input string.
- size_t EncodedSize(SpdyStringPiece in) const;
+ size_t EncodedSize(quiche::QuicheStringPiece 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 bc38f6d..abcebf8 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(SpdyStringPiece input) {
+ std::string EncodeString(quiche::QuicheStringPiece input) {
std::string result;
HpackOutputStream output_stream;
table_.EncodeString(input, &output_stream);
@@ -171,10 +171,12 @@
EXPECT_EQ(0b10011000, peer_.pad_bits());
char input_storage[] = {2, 3, 2, 7, 4};
- SpdyStringPiece input(input_storage, QUICHE_ARRAYSIZE(input_storage));
+ quiche::QuicheStringPiece 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};
- SpdyStringPiece expect(expect_storage, QUICHE_ARRAYSIZE(expect_storage));
+ quiche::QuicheStringPiece expect(expect_storage,
+ QUICHE_ARRAYSIZE(expect_storage));
EXPECT_EQ(expect, EncodeString(input));
}
@@ -256,7 +258,7 @@
for (size_t i = 0; i != 256; i++) {
char c = static_cast<char>(i);
char storage[3] = {c, c, c};
- SpdyStringPiece input(storage, QUICHE_ARRAYSIZE(storage));
+ quiche::QuicheStringPiece input(storage, QUICHE_ARRAYSIZE(storage));
std::string buffer_in = EncodeString(input);
std::string buffer_out;
DecodeString(buffer_in, &buffer_out);
@@ -270,7 +272,7 @@
storage[i] = static_cast<char>(i);
storage[511 - i] = static_cast<char>(i);
}
- SpdyStringPiece input(storage, QUICHE_ARRAYSIZE(storage));
+ quiche::QuicheStringPiece 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 4ceaece..5c2dd68 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(SpdyStringPiece buffer) {
+void HpackOutputStream::AppendBytes(quiche::QuicheStringPiece 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 5e65139..9b64554 100644
--- a/spdy/core/hpack/hpack_output_stream.h
+++ b/spdy/core/hpack/hpack_output_stream.h
@@ -9,9 +9,9 @@
#include <map>
#include <string>
+#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"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
// All section references below are to
// http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-08
@@ -37,7 +37,7 @@
void AppendPrefix(HpackPrefix prefix);
// Directly appends |buffer|.
- void AppendBytes(SpdyStringPiece buffer);
+ void AppendBytes(quiche::QuicheStringPiece 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 eea1d9e..e8b07f1 100644
--- a/spdy/core/hpack/hpack_static_table.cc
+++ b/spdy/core/hpack/hpack_static_table.cc
@@ -4,11 +4,11 @@
#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 "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"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_logging.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
namespace spdy {
@@ -24,8 +24,8 @@
for (const HpackStaticEntry* it = static_entry_table;
it != static_entry_table + static_entry_count; ++it) {
static_entries_.push_back(
- HpackEntry(SpdyStringPiece(it->name, it->name_len),
- SpdyStringPiece(it->value, it->value_len),
+ HpackEntry(quiche::QuicheStringPiece(it->name, it->name_len),
+ quiche::QuicheStringPiece(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 3f51955..4cd310f 100644
--- a/spdy/core/hpack/hpack_static_table_test.cc
+++ b/spdy/core/hpack/hpack_static_table_test.cc
@@ -7,8 +7,8 @@
#include <set>
#include <vector>
+#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"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
#include "net/third_party/quiche/src/spdy/platform/api/spdy_test.h"
namespace spdy {
@@ -39,7 +39,7 @@
HpackHeaderTable::NameToEntryMap static_name_index =
table_.GetStaticNameIndex();
- std::set<SpdyStringPiece> names;
+ std::set<quiche::QuicheStringPiece> names;
for (auto* entry : static_index) {
names.insert(entry->name());
}
