Use quiche string libraries in third_party/quic/core/http
gfe-relnote: n/a, no functional change
PiperOrigin-RevId: 285397956
Change-Id: I2f881affa932f79d84ea11c7ead81bd1dca9be4b
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 0cdb5c7..d006acd 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -31,11 +31,8 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_port_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_sleep.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test_loopback.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/quic/platform/impl/quic_socket_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/bad_packet_writer.h"
#include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
@@ -65,6 +62,9 @@
#include "net/third_party/quiche/src/quic/tools/quic_server.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_client_stream.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_server_stream.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"
using spdy::kV3LowestPriority;
using spdy::SpdyFramer;
@@ -115,7 +115,7 @@
// Used by ::testing::PrintToStringParamName().
std::string PrintToString(const TestParams& p) {
- std::string rv = QuicStrCat(
+ std::string rv = quiche::QuicheStrCat(
ParsedQuicVersionToString(p.negotiated_version), "_Server_",
ParsedQuicVersionVectorToString(p.server_supported_versions), "_Client_",
ParsedQuicVersionVectorToString(p.client_supported_versions), "_",
@@ -476,9 +476,9 @@
}
}
- void AddToCache(QuicStringPiece path,
+ void AddToCache(quiche::QuicheStringPiece path,
int response_code,
- QuicStringPiece body) {
+ quiche::QuicheStringPiece body) {
memory_cache_backend_.AddSimpleResponse(server_hostname_, path,
response_code, body);
}
@@ -2903,7 +2903,7 @@
SpdyHeaderBlock headers;
headers[":status"] = "500";
headers["content-length"] =
- QuicTextUtils::Uint64ToString(response_body_.size());
+ quiche::QuicheTextUtils::Uint64ToString(response_body_.size());
// This method must call CloseReadSide to cause the test case, StopReading
// is not sufficient.
QuicStreamPeer::CloseReadSide(this);
@@ -3122,7 +3122,8 @@
SpdyHeaderBlock headers;
headers[":status"] = "200";
- headers["content-length"] = QuicTextUtils::Uint64ToString(kBody.size());
+ headers["content-length"] =
+ quiche::QuicheTextUtils::Uint64ToString(kBody.size());
SpdyHeaderBlock trailers;
trailers["some-trailing-header"] = "trailing-header-value";
@@ -3173,11 +3174,12 @@
std::string body =
use_large_response
? large_resource
- : QuicStrCat("This is server push response body for ", url);
+ : quiche::QuicheStrCat("This is server push response body for ",
+ url);
SpdyHeaderBlock response_headers;
response_headers[":status"] = "200";
response_headers["content-length"] =
- QuicTextUtils::Uint64ToString(body.size());
+ quiche::QuicheTextUtils::Uint64ToString(body.size());
push_resources.push_back(QuicBackendResponse::ServerPushInfo(
resource_url, std::move(response_headers), kV3LowestPriority, body));
}
@@ -3235,7 +3237,7 @@
for (const std::string& url : push_urls) {
QUIC_DVLOG(1) << "send request for pushed stream on url " << url;
std::string expected_body =
- QuicStrCat("This is server push response body for ", url);
+ quiche::QuicheStrCat("This is server push response body for ", url);
std::string response_body = client_->SendSynchronousRequest(url);
QUIC_DVLOG(1) << "response body " << response_body;
EXPECT_EQ(expected_body, response_body);
@@ -3288,7 +3290,7 @@
// as the responses are already in the client's cache.
QUIC_DVLOG(1) << "send request for pushed stream on url " << url;
std::string expected_body =
- QuicStrCat("This is server push response body for ", url);
+ quiche::QuicheStrCat("This is server push response body for ", url);
std::string response_body = client_->SendSynchronousRequest(url);
QUIC_DVLOG(1) << "response body " << response_body;
EXPECT_EQ(expected_body, response_body);
@@ -3327,7 +3329,8 @@
const size_t kNumResources = 1 + kNumMaxStreams; // 11.
std::string push_urls[11];
for (size_t i = 0; i < kNumResources; ++i) {
- push_urls[i] = QuicStrCat("https://example.com/push_resources", i);
+ push_urls[i] =
+ quiche::QuicheStrCat("https://example.com/push_resources", i);
}
AddRequestAndResponseWithServerPush("example.com", "/push_example", kBody,
push_urls, kNumResources, 0);
@@ -3344,8 +3347,9 @@
for (const std::string& url : push_urls) {
// Sending subsequent requesets will not actually send anything on the wire,
// as the responses are already in the client's cache.
- EXPECT_EQ(QuicStrCat("This is server push response body for ", url),
- client_->SendSynchronousRequest(url));
+ EXPECT_EQ(
+ quiche::QuicheStrCat("This is server push response body for ", url),
+ client_->SendSynchronousRequest(url));
}
// Only 1 request should have been sent.
@@ -3385,7 +3389,7 @@
const size_t kNumResources = kNumMaxStreams + 1;
std::string push_urls[11];
for (size_t i = 0; i < kNumResources; ++i) {
- push_urls[i] = QuicStrCat("http://example.com/push_resources", i);
+ push_urls[i] = quiche::QuicheStrCat("http://example.com/push_resources", i);
}
AddRequestAndResponseWithServerPush("example.com", "/push_example", kBody,
push_urls, kNumResources, kBodySize);
@@ -3462,7 +3466,7 @@
headers[":scheme"] = "https";
headers[":authority"] = server_hostname_;
headers["content-length"] =
- QuicTextUtils::Uint64ToString(request_body_size_bytes);
+ quiche::QuicheTextUtils::Uint64ToString(request_body_size_bytes);
client_->SendMessage(headers, "", /*fin=*/false);
@@ -3794,9 +3798,9 @@
// (and the FIN) after the response body.
std::string response_body(1305, 'a');
SpdyHeaderBlock response_headers;
- response_headers[":status"] = QuicTextUtils::Uint64ToString(200);
+ response_headers[":status"] = quiche::QuicheTextUtils::Uint64ToString(200);
response_headers["content-length"] =
- QuicTextUtils::Uint64ToString(response_body.length());
+ quiche::QuicheTextUtils::Uint64ToString(response_body.length());
memory_cache_backend_.AddSpecialResponse(
server_hostname_, "/test_url", std::move(response_headers), response_body,
QuicBackendResponse::INCOMPLETE_RESPONSE);
@@ -3853,22 +3857,22 @@
ASSERT_LT(0, client_session->GetCurrentLargestMessagePayload());
std::string message_string(kMaxOutgoingPacketSize, 'a');
- QuicStringPiece message_buffer(message_string);
+ quiche::QuicheStringPiece message_buffer(message_string);
QuicRandom* random =
QuicConnectionPeer::GetHelper(client_connection)->GetRandomGenerator();
QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
{
QuicConnection::ScopedPacketFlusher flusher(client_session->connection());
// Verify the largest message gets successfully sent.
- EXPECT_EQ(
- MessageResult(MESSAGE_STATUS_SUCCESS, 1),
- client_session->SendMessage(MakeSpan(
- client_session->connection()
- ->helper()
- ->GetStreamSendBufferAllocator(),
- QuicStringPiece(message_buffer.data(),
- client_session->GetCurrentLargestMessagePayload()),
- &storage)));
+ EXPECT_EQ(MessageResult(MESSAGE_STATUS_SUCCESS, 1),
+ client_session->SendMessage(MakeSpan(
+ client_session->connection()
+ ->helper()
+ ->GetStreamSendBufferAllocator(),
+ quiche::QuicheStringPiece(
+ message_buffer.data(),
+ client_session->GetCurrentLargestMessagePayload()),
+ &storage)));
// Send more messages with size (0, largest_payload] until connection is
// write blocked.
const int kTestMaxNumberOfMessages = 100;
@@ -3881,7 +3885,8 @@
client_session->connection()
->helper()
->GetStreamSendBufferAllocator(),
- QuicStringPiece(message_buffer.data(), message_length), &storage));
+ quiche::QuicheStringPiece(message_buffer.data(), message_length),
+ &storage));
if (result.status == MESSAGE_STATUS_BLOCKED) {
// Connection is write blocked.
break;
@@ -3897,7 +3902,7 @@
client_session->connection()
->helper()
->GetStreamSendBufferAllocator(),
- QuicStringPiece(
+ quiche::QuicheStringPiece(
message_buffer.data(),
client_session->GetCurrentLargestMessagePayload() + 1),
&storage))
@@ -4026,9 +4031,9 @@
// frame for the stream.
std::string response_body(1305, 'a');
SpdyHeaderBlock response_headers;
- response_headers[":status"] = QuicTextUtils::Uint64ToString(200);
+ response_headers[":status"] = quiche::QuicheTextUtils::Uint64ToString(200);
response_headers["content-length"] =
- QuicTextUtils::Uint64ToString(response_body.length());
+ quiche::QuicheTextUtils::Uint64ToString(response_body.length());
memory_cache_backend_.AddStopSendingResponse(
server_hostname_, "/test_url", std::move(response_headers), response_body,
kStopSendingTestCode);
diff --git a/quic/core/http/http_decoder.cc b/quic/core/http/http_decoder.cc
index 41632a9..51c70e0 100644
--- a/quic/core/http/http_decoder.cc
+++ b/quic/core/http/http_decoder.cc
@@ -11,6 +11,7 @@
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_fallthrough.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -190,7 +191,7 @@
case static_cast<uint64_t>(HttpFrameType::DATA): {
QuicByteCount bytes_to_read = std::min<QuicByteCount>(
remaining_frame_length_, reader->BytesRemaining());
- QuicStringPiece payload;
+ quiche::QuicheStringPiece payload;
bool success = reader->ReadStringPiece(&payload, bytes_to_read);
DCHECK(success);
DCHECK(!payload.empty());
@@ -201,7 +202,7 @@
case static_cast<uint64_t>(HttpFrameType::HEADERS): {
QuicByteCount bytes_to_read = std::min<QuicByteCount>(
remaining_frame_length_, reader->BytesRemaining());
- QuicStringPiece payload;
+ quiche::QuicheStringPiece payload;
bool success = reader->ReadStringPiece(&payload, bytes_to_read);
DCHECK(success);
DCHECK(!payload.empty());
@@ -277,7 +278,7 @@
if (bytes_to_read == 0) {
break;
}
- QuicStringPiece payload;
+ quiche::QuicheStringPiece payload;
bool success = reader->ReadStringPiece(&payload, bytes_to_read);
DCHECK(success);
DCHECK(!payload.empty());
@@ -300,7 +301,7 @@
default: {
QuicByteCount bytes_to_read = std::min<QuicByteCount>(
remaining_frame_length_, reader->BytesRemaining());
- QuicStringPiece payload;
+ quiche::QuicheStringPiece payload;
bool success = reader->ReadStringPiece(&payload, bytes_to_read);
DCHECK(success);
DCHECK(!payload.empty());
@@ -440,7 +441,7 @@
void HttpDecoder::DiscardFramePayload(QuicDataReader* reader) {
QuicByteCount bytes_to_read = std::min<QuicByteCount>(
remaining_frame_length_, reader->BytesRemaining());
- QuicStringPiece payload;
+ quiche::QuicheStringPiece payload;
bool success = reader->ReadStringPiece(&payload, bytes_to_read);
DCHECK(success);
remaining_frame_length_ -= payload.length();
diff --git a/quic/core/http/http_decoder.h b/quic/core/http/http_decoder.h
index 862c5de..1dc2225 100644
--- a/quic/core/http/http_decoder.h
+++ b/quic/core/http/http_decoder.h
@@ -11,7 +11,7 @@
#include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -70,7 +70,7 @@
// Called when part of the payload of a DATA frame has been read. May be
// called multiple times for a single frame. |payload| is guaranteed to be
// non-empty.
- virtual bool OnDataFramePayload(QuicStringPiece payload) = 0;
+ virtual bool OnDataFramePayload(quiche::QuicheStringPiece payload) = 0;
// Called when a DATA frame has been completely processed.
virtual bool OnDataFrameEnd() = 0;
@@ -80,7 +80,7 @@
// Called when part of the payload of a HEADERS frame has been read. May be
// called multiple times for a single frame. |payload| is guaranteed to be
// non-empty.
- virtual bool OnHeadersFramePayload(QuicStringPiece payload) = 0;
+ virtual bool OnHeadersFramePayload(quiche::QuicheStringPiece payload) = 0;
// Called when a HEADERS frame has been completely processed.
// |frame_len| is the length of the HEADERS frame payload.
virtual bool OnHeadersFrameEnd() = 0;
@@ -94,7 +94,8 @@
// Called when part of the header block of a PUSH_PROMISE frame has been
// read. May be called multiple times for a single frame. |payload| is
// guaranteed to be non-empty.
- virtual bool OnPushPromiseFramePayload(QuicStringPiece payload) = 0;
+ virtual bool OnPushPromiseFramePayload(
+ quiche::QuicheStringPiece payload) = 0;
// Called when a PUSH_PROMISE frame has been completely processed.
virtual bool OnPushPromiseFrameEnd() = 0;
@@ -106,7 +107,7 @@
// Called when part of the payload of the unknown frame has been read. May
// be called multiple times for a single frame. |payload| is guaranteed to
// be non-empty.
- virtual bool OnUnknownFramePayload(QuicStringPiece payload) = 0;
+ virtual bool OnUnknownFramePayload(quiche::QuicheStringPiece payload) = 0;
// Called when the unknown frame has been completely processed.
virtual bool OnUnknownFrameEnd() = 0;
};
diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc
index 751ca58..6796d25 100644
--- a/quic/core/http/http_decoder_test.cc
+++ b/quic/core/http/http_decoder_test.cc
@@ -12,10 +12,11 @@
#include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
#include "net/third_party/quiche/src/quic/core/quic_versions.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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"
using ::testing::_;
using ::testing::Eq;
@@ -50,21 +51,22 @@
MOCK_METHOD1(OnDuplicatePushFrame, bool(const DuplicatePushFrame& frame));
MOCK_METHOD1(OnDataFrameStart, bool(QuicByteCount header_length));
- MOCK_METHOD1(OnDataFramePayload, bool(QuicStringPiece payload));
+ MOCK_METHOD1(OnDataFramePayload, bool(quiche::QuicheStringPiece payload));
MOCK_METHOD0(OnDataFrameEnd, bool());
MOCK_METHOD1(OnHeadersFrameStart, bool(QuicByteCount header_length));
- MOCK_METHOD1(OnHeadersFramePayload, bool(QuicStringPiece payload));
+ MOCK_METHOD1(OnHeadersFramePayload, bool(quiche::QuicheStringPiece payload));
MOCK_METHOD0(OnHeadersFrameEnd, bool());
MOCK_METHOD1(OnPushPromiseFrameStart, bool(QuicByteCount header_length));
MOCK_METHOD2(OnPushPromiseFramePushId,
bool(PushId push_id, QuicByteCount push_id_length));
- MOCK_METHOD1(OnPushPromiseFramePayload, bool(QuicStringPiece payload));
+ MOCK_METHOD1(OnPushPromiseFramePayload,
+ bool(quiche::QuicheStringPiece payload));
MOCK_METHOD0(OnPushPromiseFrameEnd, bool());
MOCK_METHOD2(OnUnknownFrameStart, bool(uint64_t, QuicByteCount));
- MOCK_METHOD1(OnUnknownFramePayload, bool(QuicStringPiece));
+ MOCK_METHOD1(OnUnknownFramePayload, bool(quiche::QuicheStringPiece));
MOCK_METHOD0(OnUnknownFrameEnd, bool());
};
@@ -101,13 +103,13 @@
}
// Process |input| in a single call to HttpDecoder::ProcessInput().
- QuicByteCount ProcessInput(QuicStringPiece input) {
+ QuicByteCount ProcessInput(quiche::QuicheStringPiece input) {
return decoder_.ProcessInput(input.data(), input.size());
}
// Feed |input| to |decoder_| one character at a time,
// verifying that each character gets processed.
- void ProcessInputCharByChar(QuicStringPiece input) {
+ void ProcessInputCharByChar(quiche::QuicheStringPiece input) {
for (char c : input) {
EXPECT_EQ(1u, decoder_.ProcessInput(&c, 1));
}
@@ -115,8 +117,10 @@
// Append garbage to |input|, then process it in a single call to
// HttpDecoder::ProcessInput(). Verify that garbage is not read.
- QuicByteCount ProcessInputWithGarbageAppended(QuicStringPiece input) {
- std::string input_with_garbage_appended = QuicStrCat(input, "blahblah");
+ QuicByteCount ProcessInputWithGarbageAppended(
+ quiche::QuicheStringPiece input) {
+ std::string input_with_garbage_appended =
+ quiche::QuicheStrCat(input, "blahblah");
QuicByteCount processed_bytes = ProcessInput(input_with_garbage_appended);
// Guaranteed by HttpDecoder::ProcessInput() contract.
@@ -181,7 +185,7 @@
TEST_F(HttpDecoderTest, CancelPush) {
InSequence s;
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"03" // type (CANCEL_PUSH)
"01" // length
"01"); // Push Id
@@ -208,17 +212,17 @@
TEST_F(HttpDecoderTest, PushPromiseFrame) {
InSequence s;
- std::string input =
- QuicStrCat(QuicTextUtils::HexDecode("05" // type (PUSH PROMISE)
- "0f" // length
- "C000000000000101"), // push id 257
- "Headers"); // headers
+ std::string input = quiche::QuicheStrCat(
+ quiche::QuicheTextUtils::HexDecode("05" // type (PUSH PROMISE)
+ "0f" // length
+ "C000000000000101"), // push id 257
+ "Headers"); // headers
// Visitor pauses processing.
EXPECT_CALL(visitor_, OnPushPromiseFrameStart(2)).WillOnce(Return(false));
EXPECT_CALL(visitor_, OnPushPromiseFramePushId(257, 8))
.WillOnce(Return(false));
- QuicStringPiece remaining_input(input);
+ quiche::QuicheStringPiece remaining_input(input);
QuicByteCount processed_bytes =
ProcessInputWithGarbageAppended(remaining_input);
EXPECT_EQ(2u, processed_bytes);
@@ -227,7 +231,8 @@
EXPECT_EQ(8u, processed_bytes);
remaining_input = remaining_input.substr(processed_bytes);
- EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("Headers")))
+ EXPECT_CALL(visitor_,
+ OnPushPromiseFramePayload(quiche::QuicheStringPiece("Headers")))
.WillOnce(Return(false));
processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
EXPECT_EQ(remaining_input.size(), processed_bytes);
@@ -240,7 +245,8 @@
// Process the full frame.
EXPECT_CALL(visitor_, OnPushPromiseFrameStart(2));
EXPECT_CALL(visitor_, OnPushPromiseFramePushId(257, 8));
- EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("Headers")));
+ EXPECT_CALL(visitor_,
+ OnPushPromiseFramePayload(quiche::QuicheStringPiece("Headers")));
EXPECT_CALL(visitor_, OnPushPromiseFrameEnd());
EXPECT_EQ(input.size(), ProcessInput(input));
EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -249,13 +255,20 @@
// Process the frame incrementally.
EXPECT_CALL(visitor_, OnPushPromiseFrameStart(2));
EXPECT_CALL(visitor_, OnPushPromiseFramePushId(257, 8));
- EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("H")));
- EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("e")));
- EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("a")));
- EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("d")));
- EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("e")));
- EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("r")));
- EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("s")));
+ EXPECT_CALL(visitor_,
+ OnPushPromiseFramePayload(quiche::QuicheStringPiece("H")));
+ EXPECT_CALL(visitor_,
+ OnPushPromiseFramePayload(quiche::QuicheStringPiece("e")));
+ EXPECT_CALL(visitor_,
+ OnPushPromiseFramePayload(quiche::QuicheStringPiece("a")));
+ EXPECT_CALL(visitor_,
+ OnPushPromiseFramePayload(quiche::QuicheStringPiece("d")));
+ EXPECT_CALL(visitor_,
+ OnPushPromiseFramePayload(quiche::QuicheStringPiece("e")));
+ EXPECT_CALL(visitor_,
+ OnPushPromiseFramePayload(quiche::QuicheStringPiece("r")));
+ EXPECT_CALL(visitor_,
+ OnPushPromiseFramePayload(quiche::QuicheStringPiece("s")));
EXPECT_CALL(visitor_, OnPushPromiseFrameEnd());
ProcessInputCharByChar(input);
EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -264,7 +277,8 @@
// Process push id incrementally and append headers with last byte of push id.
EXPECT_CALL(visitor_, OnPushPromiseFrameStart(2));
EXPECT_CALL(visitor_, OnPushPromiseFramePushId(257, 8));
- EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("Headers")));
+ EXPECT_CALL(visitor_,
+ OnPushPromiseFramePayload(quiche::QuicheStringPiece("Headers")));
EXPECT_CALL(visitor_, OnPushPromiseFrameEnd());
ProcessInputCharByChar(input.substr(0, 9));
EXPECT_EQ(8u, ProcessInput(input.substr(9)));
@@ -275,7 +289,7 @@
TEST_F(HttpDecoderTest, CorruptPushPromiseFrame) {
InSequence s;
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"05" // type (PUSH_PROMISE)
"01" // length
"40"); // first byte of two-byte varint push id
@@ -306,7 +320,7 @@
TEST_F(HttpDecoderTest, MaxPushId) {
InSequence s;
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"0D" // type (MAX_PUSH_ID)
"01" // length
"01"); // Push Id
@@ -333,7 +347,7 @@
TEST_F(HttpDecoderTest, DuplicatePush) {
InSequence s;
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"0E" // type (DUPLICATE_PUSH)
"01" // length
"01"); // Push Id
@@ -360,7 +374,7 @@
TEST_F(HttpDecoderTest, PriorityFrame) {
InSequence s;
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"02" // type (PRIORITY)
"04" // length
"08" // request stream, request stream, exclusive
@@ -378,7 +392,7 @@
// Visitor pauses processing.
EXPECT_CALL(visitor_, OnPriorityFrameStart(2)).WillOnce(Return(false));
- QuicStringPiece remaining_input(input);
+ quiche::QuicheStringPiece remaining_input(input);
QuicByteCount processed_bytes =
ProcessInputWithGarbageAppended(remaining_input);
EXPECT_EQ(2u, processed_bytes);
@@ -404,7 +418,7 @@
EXPECT_THAT(decoder_.error(), IsQuicNoError());
EXPECT_EQ("", decoder_.error_detail());
- std::string input2 = QuicTextUtils::HexDecode(
+ std::string input2 = quiche::QuicheTextUtils::HexDecode(
"02" // type (PRIORITY)
"02" // length
"f8" // root of tree, root of tree, exclusive
@@ -470,7 +484,7 @@
TEST_F(HttpDecoderTest, SettingsFrame) {
InSequence s;
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"04" // type (SETTINGS)
"07" // length
"01" // identifier (SETTINGS_QPACK_MAX_TABLE_CAPACITY)
@@ -486,7 +500,7 @@
frame.values[256] = 4;
// Visitor pauses processing.
- QuicStringPiece remaining_input(input);
+ quiche::QuicheStringPiece remaining_input(input);
EXPECT_CALL(visitor_, OnSettingsFrameStart(2)).WillOnce(Return(false));
QuicByteCount processed_bytes =
ProcessInputWithGarbageAppended(remaining_input);
@@ -550,7 +564,7 @@
}
TEST_F(HttpDecoderTest, DuplicateSettingsIdentifier) {
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"04" // type (SETTINGS)
"04" // length
"01" // identifier
@@ -569,19 +583,20 @@
TEST_F(HttpDecoderTest, DataFrame) {
InSequence s;
- std::string input = QuicStrCat(QuicTextUtils::HexDecode("00" // type (DATA)
- "05"), // length
- "Data!"); // data
+ std::string input = quiche::QuicheStrCat(
+ quiche::QuicheTextUtils::HexDecode("00" // type (DATA)
+ "05"), // length
+ "Data!"); // data
// Visitor pauses processing.
EXPECT_CALL(visitor_, OnDataFrameStart(2)).WillOnce(Return(false));
- QuicStringPiece remaining_input(input);
+ quiche::QuicheStringPiece remaining_input(input);
QuicByteCount processed_bytes =
ProcessInputWithGarbageAppended(remaining_input);
EXPECT_EQ(2u, processed_bytes);
remaining_input = remaining_input.substr(processed_bytes);
- EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("Data!")))
+ EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("Data!")))
.WillOnce(Return(false));
processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
EXPECT_EQ(remaining_input.size(), processed_bytes);
@@ -593,7 +608,7 @@
// Process the full frame.
EXPECT_CALL(visitor_, OnDataFrameStart(2));
- EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("Data!")));
+ EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("Data!")));
EXPECT_CALL(visitor_, OnDataFrameEnd());
EXPECT_EQ(input.size(), ProcessInput(input));
EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -601,11 +616,11 @@
// Process the frame incrementally.
EXPECT_CALL(visitor_, OnDataFrameStart(2));
- EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("D")));
- EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("a")));
- EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("t")));
- EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("a")));
- EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("!")));
+ EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("D")));
+ EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("a")));
+ EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("t")));
+ EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("a")));
+ EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("!")));
EXPECT_CALL(visitor_, OnDataFrameEnd());
ProcessInputCharByChar(input);
EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -633,7 +648,7 @@
EXPECT_EQ("", decoder_.error_detail());
// Send data.
- EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece(input)));
+ EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece(input)));
EXPECT_CALL(visitor_, OnDataFrameEnd());
EXPECT_EQ(2048u, decoder_.ProcessInput(input.data(), 2048));
EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -669,7 +684,7 @@
TEST_F(HttpDecoderTest, GoAway) {
InSequence s;
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"07" // type (GOAWAY)
"01" // length
"01"); // StreamId
@@ -696,20 +711,21 @@
TEST_F(HttpDecoderTest, HeadersFrame) {
InSequence s;
- std::string input =
- QuicStrCat(QuicTextUtils::HexDecode("01" // type (HEADERS)
- "07"), // length
- "Headers"); // headers
+ std::string input = quiche::QuicheStrCat(
+ quiche::QuicheTextUtils::HexDecode("01" // type (HEADERS)
+ "07"), // length
+ "Headers"); // headers
// Visitor pauses processing.
EXPECT_CALL(visitor_, OnHeadersFrameStart(2)).WillOnce(Return(false));
- QuicStringPiece remaining_input(input);
+ quiche::QuicheStringPiece remaining_input(input);
QuicByteCount processed_bytes =
ProcessInputWithGarbageAppended(remaining_input);
EXPECT_EQ(2u, processed_bytes);
remaining_input = remaining_input.substr(processed_bytes);
- EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("Headers")))
+ EXPECT_CALL(visitor_,
+ OnHeadersFramePayload(quiche::QuicheStringPiece("Headers")))
.WillOnce(Return(false));
processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
EXPECT_EQ(remaining_input.size(), processed_bytes);
@@ -721,7 +737,8 @@
// Process the full frame.
EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
- EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("Headers")));
+ EXPECT_CALL(visitor_,
+ OnHeadersFramePayload(quiche::QuicheStringPiece("Headers")));
EXPECT_CALL(visitor_, OnHeadersFrameEnd());
EXPECT_EQ(input.size(), ProcessInput(input));
EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -729,13 +746,13 @@
// Process the frame incrementally.
EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
- EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("H")));
- EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("e")));
- EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("a")));
- EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("d")));
- EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("e")));
- EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("r")));
- EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("s")));
+ EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("H")));
+ EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("e")));
+ EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("a")));
+ EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("d")));
+ EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("e")));
+ EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("r")));
+ EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("s")));
EXPECT_CALL(visitor_, OnHeadersFrameEnd());
ProcessInputCharByChar(input);
EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -744,7 +761,7 @@
TEST_F(HttpDecoderTest, EmptyDataFrame) {
InSequence s;
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"00" // type (DATA)
"00"); // length
@@ -774,7 +791,7 @@
TEST_F(HttpDecoderTest, EmptyHeadersFrame) {
InSequence s;
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"01" // type (HEADERS)
"00"); // length
@@ -804,7 +821,7 @@
TEST_F(HttpDecoderTest, PushPromiseFrameNoHeaders) {
InSequence s;
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"05" // type (PUSH_PROMISE)
"01" // length
"01"); // Push Id
@@ -837,7 +854,7 @@
}
TEST_F(HttpDecoderTest, MalformedFrameWithOverlyLargePayload) {
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"03" // type (CANCEL_PUSH)
"10" // length
"15"); // malformed payload
@@ -865,19 +882,20 @@
TEST_F(HttpDecoderTest, HeadersPausedThenData) {
InSequence s;
- std::string input =
- QuicStrCat(QuicTextUtils::HexDecode("01" // type (HEADERS)
- "07"), // length
- "Headers", // headers
- QuicTextUtils::HexDecode("00" // type (DATA)
- "05"), // length
- "Data!"); // data
+ std::string input = quiche::QuicheStrCat(
+ quiche::QuicheTextUtils::HexDecode("01" // type (HEADERS)
+ "07"), // length
+ "Headers", // headers
+ quiche::QuicheTextUtils::HexDecode("00" // type (DATA)
+ "05"), // length
+ "Data!"); // data
// Visitor pauses processing, maybe because header decompression is blocked.
EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
- EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("Headers")));
+ EXPECT_CALL(visitor_,
+ OnHeadersFramePayload(quiche::QuicheStringPiece("Headers")));
EXPECT_CALL(visitor_, OnHeadersFrameEnd()).WillOnce(Return(false));
- QuicStringPiece remaining_input(input);
+ quiche::QuicheStringPiece remaining_input(input);
QuicByteCount processed_bytes =
ProcessInputWithGarbageAppended(remaining_input);
EXPECT_EQ(9u, processed_bytes);
@@ -885,7 +903,7 @@
// Process DATA frame.
EXPECT_CALL(visitor_, OnDataFrameStart(2));
- EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("Data!")));
+ EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("Data!")));
EXPECT_CALL(visitor_, OnDataFrameEnd());
processed_bytes = ProcessInput(remaining_input);
@@ -943,7 +961,7 @@
HttpDecoder decoder(&visitor_);
EXPECT_CALL(visitor_, OnError(&decoder));
- QuicStringPiece input(test_data.input);
+ quiche::QuicheStringPiece input(test_data.input);
decoder.ProcessInput(input.data(), input.size());
EXPECT_THAT(decoder.error(), IsError(QUIC_INVALID_FRAME_DATA));
EXPECT_EQ(test_data.error_message, decoder.error_detail());
@@ -952,7 +970,7 @@
HttpDecoder decoder(&visitor_);
EXPECT_CALL(visitor_, OnError(&decoder));
- QuicStringPiece input(test_data.input);
+ quiche::QuicheStringPiece input(test_data.input);
for (auto c : input) {
decoder.ProcessInput(&c, 1);
}
@@ -963,7 +981,7 @@
}
TEST_F(HttpDecoderTest, EmptyCancelPushFrame) {
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"03" // type (CANCEL_PUSH)
"00"); // frame length
@@ -974,7 +992,7 @@
}
TEST_F(HttpDecoderTest, EmptySettingsFrame) {
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"04" // type (SETTINGS)
"00"); // frame length
@@ -990,7 +1008,7 @@
// Regression test for https://crbug.com/1001823.
TEST_F(HttpDecoderTest, EmptyPushPromiseFrame) {
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"05" // type (PUSH_PROMISE)
"00"); // frame length
@@ -1001,7 +1019,7 @@
}
TEST_F(HttpDecoderTest, EmptyGoAwayFrame) {
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"07" // type (GOAWAY)
"00"); // frame length
@@ -1012,7 +1030,7 @@
}
TEST_F(HttpDecoderTest, EmptyMaxPushIdFrame) {
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"0d" // type (MAX_PUSH_ID)
"00"); // frame length
@@ -1023,7 +1041,7 @@
}
TEST_F(HttpDecoderTest, EmptyDuplicatePushFrame) {
- std::string input = QuicTextUtils::HexDecode(
+ std::string input = quiche::QuicheTextUtils::HexDecode(
"0e" // type (DUPLICATE_PUSH)
"00"); // frame length
diff --git a/quic/core/http/http_frames.h b/quic/core/http/http_frames.h
index 215fa56..de0abc4 100644
--- a/quic/core/http/http_frames.h
+++ b/quic/core/http/http_frames.h
@@ -11,9 +11,9 @@
#include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_string_utils.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/spdy/core/spdy_framer.h"
namespace quic {
@@ -35,7 +35,7 @@
// DATA frames (type=0x0) convey arbitrary, variable-length sequences of
// octets associated with an HTTP request or response payload.
struct QUIC_EXPORT_PRIVATE DataFrame {
- QuicStringPiece data;
+ quiche::QuicheStringPiece data;
};
// 4.2.2. HEADERS
@@ -43,7 +43,7 @@
// The HEADERS frame (type=0x1) is used to carry a header block,
// compressed using QPACK.
struct QUIC_EXPORT_PRIVATE HeadersFrame {
- QuicStringPiece headers;
+ quiche::QuicheStringPiece headers;
};
// 4.2.3. PRIORITY
@@ -82,12 +82,12 @@
weight == rhs.weight;
}
std::string ToString() const {
- return QuicStrCat("Priority Frame : {prioritized_type: ", prioritized_type,
- ", dependency_type: ", dependency_type,
- ", exclusive: ", exclusive,
- ", prioritized_element_id: ", prioritized_element_id,
- ", element_dependency_id: ", element_dependency_id,
- ", weight: ", weight, "}");
+ return quiche::QuicheStrCat(
+ "Priority Frame : {prioritized_type: ", prioritized_type,
+ ", dependency_type: ", dependency_type, ", exclusive: ", exclusive,
+ ", prioritized_element_id: ", prioritized_element_id,
+ ", element_dependency_id: ", element_dependency_id,
+ ", weight: ", weight, "}");
}
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
@@ -129,7 +129,7 @@
std::string ToString() const {
std::string s;
for (auto it : values) {
- std::string setting = QuicStrCat(
+ std::string setting = quiche::QuicheStrCat(
SpdyUtils::H3SettingsToString(
static_cast<Http3AndQpackSettingsIdentifiers>(it.first)),
" = ", it.second, "; ");
@@ -150,7 +150,7 @@
// set from server to client, as in HTTP/2.
struct QUIC_EXPORT_PRIVATE PushPromiseFrame {
PushId push_id;
- QuicStringPiece headers;
+ quiche::QuicheStringPiece headers;
bool operator==(const PushPromiseFrame& rhs) const {
return push_id == rhs.push_id && headers == rhs.headers;
diff --git a/quic/core/http/quic_header_list.cc b/quic/core/http/quic_header_list.cc
index cba3e58..cbf60ce 100644
--- a/quic/core/http/quic_header_list.cc
+++ b/quic/core/http/quic_header_list.cc
@@ -9,6 +9,7 @@
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
namespace quic {
@@ -35,7 +36,8 @@
<< "OnHeaderBlockStart called more than once!";
}
-void QuicHeaderList::OnHeader(QuicStringPiece name, QuicStringPiece value) {
+void QuicHeaderList::OnHeader(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value) {
// Avoid infinite buffering of headers. No longer store headers
// once the current headers are over the limit.
if (current_header_list_size_ < max_header_list_size_) {
diff --git a/quic/core/http/quic_header_list.h b/quic/core/http/quic_header_list.h
index cc6e7bc..c019ceb 100644
--- a/quic/core/http/quic_header_list.h
+++ b/quic/core/http/quic_header_list.h
@@ -13,7 +13,7 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.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"
@@ -36,7 +36,8 @@
// From SpdyHeadersHandlerInteface.
void OnHeaderBlockStart() override;
- void OnHeader(QuicStringPiece name, QuicStringPiece value) override;
+ void OnHeader(quiche::QuicheStringPiece name,
+ quiche::QuicheStringPiece value) override;
void OnHeaderBlockEnd(size_t uncompressed_header_bytes,
size_t compressed_header_bytes) override;
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index 4cf11cc..35c74fc 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -18,14 +18,14 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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/spdy/core/http2_frame_decoder_adapter.h"
#include "net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h"
#include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
@@ -128,7 +128,7 @@
MOCK_METHOD2(OnContinuation, void(SpdyStreamId stream_id, bool end));
MOCK_METHOD3(OnAltSvc,
void(SpdyStreamId stream_id,
- QuicStringPiece origin,
+ quiche::QuicheStringPiece origin,
const SpdyAltSvcWireFormat::AlternativeServiceVector&
altsvc_vector));
MOCK_METHOD4(OnPriority,
@@ -163,7 +163,7 @@
// Used by ::testing::PrintToStringParamName().
std::string PrintToString(const TestParams& tp) {
- return QuicStrCat(
+ return quiche::QuicheStrCat(
ParsedQuicVersionToString(tp.version), "_",
(tp.perspective == Perspective::IS_CLIENT ? "client" : "server"));
}
@@ -244,7 +244,7 @@
return true;
}
- void SaveHeaderDataStringPiece(QuicStringPiece data) {
+ void SaveHeaderDataStringPiece(quiche::QuicheStringPiece data) {
saved_header_data_.append(data.data(), data.length());
}
@@ -661,30 +661,34 @@
SpdySerializedFrame frame(framer_->SerializeFrame(data));
EXPECT_CALL(
*connection_,
- CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
- QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
- SETTINGS_MAX_CONCURRENT_STREAMS),
- _));
+ CloseConnection(
+ QUIC_INVALID_HEADERS_STREAM_DATA,
+ quiche::QuicheStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
+ SETTINGS_MAX_CONCURRENT_STREAMS),
+ _));
EXPECT_CALL(
*connection_,
- CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
- QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
- SETTINGS_INITIAL_WINDOW_SIZE),
- _));
+ CloseConnection(
+ QUIC_INVALID_HEADERS_STREAM_DATA,
+ quiche::QuicheStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
+ SETTINGS_INITIAL_WINDOW_SIZE),
+ _));
if (session_.perspective() == Perspective::IS_CLIENT) {
- EXPECT_CALL(*connection_,
- CloseConnection(
- QUIC_INVALID_HEADERS_STREAM_DATA,
- QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
- SETTINGS_ENABLE_PUSH),
- _));
+ EXPECT_CALL(
+ *connection_,
+ CloseConnection(
+ QUIC_INVALID_HEADERS_STREAM_DATA,
+ quiche::QuicheStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
+ SETTINGS_ENABLE_PUSH),
+ _));
}
EXPECT_CALL(
*connection_,
- CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
- QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
- SETTINGS_MAX_FRAME_SIZE),
- _));
+ CloseConnection(
+ QUIC_INVALID_HEADERS_STREAM_DATA,
+ quiche::QuicheStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
+ SETTINGS_MAX_FRAME_SIZE),
+ _));
stream_frame_.data_buffer = frame.data();
stream_frame_.data_length = frame.size();
headers_stream_->OnStreamFrame(stream_frame_);
diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index c949fa7..26d2e82 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -11,6 +11,7 @@
#include "net/third_party/quiche/src/quic/core/http/quic_spdy_session.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -95,7 +96,7 @@
return false;
}
- bool OnDataFramePayload(QuicStringPiece /*payload*/) override {
+ bool OnDataFramePayload(quiche::QuicheStringPiece /*payload*/) override {
CloseConnectionOnWrongFrame("Data");
return false;
}
@@ -110,7 +111,7 @@
return false;
}
- bool OnHeadersFramePayload(QuicStringPiece /*payload*/) override {
+ bool OnHeadersFramePayload(quiche::QuicheStringPiece /*payload*/) override {
CloseConnectionOnWrongFrame("Headers");
return false;
}
@@ -131,7 +132,8 @@
return false;
}
- bool OnPushPromiseFramePayload(QuicStringPiece /*payload*/) override {
+ bool OnPushPromiseFramePayload(
+ quiche::QuicheStringPiece /*payload*/) override {
CloseConnectionOnWrongFrame("Push Promise");
return false;
}
@@ -147,7 +149,7 @@
return true;
}
- bool OnUnknownFramePayload(QuicStringPiece /* payload */) override {
+ bool OnUnknownFramePayload(quiche::QuicheStringPiece /* payload */) override {
// Ignore unknown frame types.
return true;
}
@@ -158,11 +160,11 @@
}
private:
- void CloseConnectionOnWrongFrame(QuicStringPiece frame_type) {
+ void CloseConnectionOnWrongFrame(quiche::QuicheStringPiece frame_type) {
// TODO(renjietang): Change to HTTP/3 error type.
stream_->session()->connection()->CloseConnection(
QUIC_HTTP_DECODER_ERROR,
- QuicStrCat(frame_type, " frame received on control stream"),
+ quiche::QuicheStrCat(frame_type, " frame received on control stream"),
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
}
diff --git a/quic/core/http/quic_receive_control_stream_test.cc b/quic/core/http/quic_receive_control_stream_test.cc
index 8418766..b9a2923 100644
--- a/quic/core/http/quic_receive_control_stream_test.cc
+++ b/quic/core/http/quic_receive_control_stream_test.cc
@@ -8,10 +8,11 @@
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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 quic {
namespace test {
@@ -43,7 +44,7 @@
// Used by ::testing::PrintToStringParamName().
std::string PrintToString(const TestParams& tp) {
- return QuicStrCat(
+ return quiche::QuicheStrCat(
ParsedQuicVersionToString(tp.version), "_",
(tp.perspective == Perspective::IS_CLIENT ? "client" : "server"));
}
@@ -88,7 +89,7 @@
session_.transport_version(), 3);
char type[] = {kControlStream};
- QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+ QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
session_.OnStreamFrame(data1);
receive_control_stream_ =
@@ -285,7 +286,7 @@
// Regression test for b/137554973: unknown frames should be consumed.
TEST_P(QuicReceiveControlStreamTest, ConsumeUnknownFrame) {
- std::string unknown_frame = QuicTextUtils::HexDecode(
+ std::string unknown_frame = quiche::QuicheTextUtils::HexDecode(
"21" // reserved frame type
"03" // payload length
"666f6f"); // payload "foo"
diff --git a/quic/core/http/quic_send_control_stream.cc b/quic/core/http/quic_send_control_stream.cc
index ed7cd7f..abb21ae 100644
--- a/quic/core/http/quic_send_control_stream.cc
+++ b/quic/core/http/quic_send_control_stream.cc
@@ -11,7 +11,7 @@
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -46,8 +46,8 @@
char data[sizeof(kControlStream)];
QuicDataWriter writer(QUIC_ARRAYSIZE(data), data);
writer.WriteVarInt62(kControlStream);
- WriteOrBufferData(QuicStringPiece(writer.data(), writer.length()), false,
- nullptr);
+ WriteOrBufferData(quiche::QuicheStringPiece(writer.data(), writer.length()),
+ false, nullptr);
SettingsFrame settings;
settings.values[SETTINGS_QPACK_MAX_TABLE_CAPACITY] =
@@ -66,7 +66,7 @@
if (spdy_session->debug_visitor() != nullptr) {
spdy_session->debug_visitor()->OnSettingsFrameSent(settings);
}
- WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length),
+ WriteOrBufferData(quiche::QuicheStringPiece(buffer.get(), frame_length),
/*fin = */ false, nullptr);
settings_sent_ = true;
}
@@ -78,8 +78,8 @@
QuicByteCount frame_length =
HttpEncoder::SerializePriorityFrame(priority, &buffer);
QUIC_DVLOG(1) << "Control Stream " << id() << " is writing " << priority;
- WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length), false,
- nullptr);
+ WriteOrBufferData(quiche::QuicheStringPiece(buffer.get(), frame_length),
+ false, nullptr);
}
void QuicSendControlStream::SendMaxPushIdFrame(PushId max_push_id) {
@@ -91,7 +91,7 @@
std::unique_ptr<char[]> buffer;
QuicByteCount frame_length =
HttpEncoder::SerializeMaxPushIdFrame(frame, &buffer);
- WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length),
+ WriteOrBufferData(quiche::QuicheStringPiece(buffer.get(), frame_length),
/*fin = */ false, nullptr);
}
@@ -110,8 +110,8 @@
std::unique_ptr<char[]> buffer;
QuicByteCount frame_length =
HttpEncoder::SerializeGoAwayFrame(frame, &buffer);
- WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length), false,
- nullptr);
+ WriteOrBufferData(quiche::QuicheStringPiece(buffer.get(), frame_length),
+ false, nullptr);
}
} // namespace quic
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc
index de2e705..9d3504e 100644
--- a/quic/core/http/quic_send_control_stream_test.cc
+++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -6,10 +6,11 @@
#include <utility>
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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 quic {
namespace test {
@@ -43,7 +44,7 @@
// Used by ::testing::PrintToStringParamName().
std::string PrintToString(const TestParams& tp) {
- return QuicStrCat(
+ return quiche::QuicheStrCat(
ParsedQuicVersionToString(tp.version), "_",
(tp.perspective == Perspective::IS_CLIENT ? "client" : "server"));
}
@@ -109,7 +110,7 @@
Initialize();
testing::InSequence s;
- std::string expected_write_data = QuicTextUtils::HexDecode(
+ std::string expected_write_data = quiche::QuicheTextUtils::HexDecode(
"00" // stream type: control stream
"04" // frame type: SETTINGS frame
"08" // frame length
@@ -141,7 +142,7 @@
send_control_stream_->MaybeSendSettingsFrame();
EXPECT_EQ(expected_write_data,
- QuicStringPiece(writer.data(), writer.length()));
+ quiche::QuicheStringPiece(writer.data(), writer.length()));
}
TEST_P(QuicSendControlStreamTest, WriteSettingsOnlyOnce) {
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index a1b1b3c..c13709e 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -36,6 +36,7 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_server_stream.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
using testing::_;
using testing::StrictMock;
@@ -235,7 +236,7 @@
// Open a stream, then reset it.
// Send two bytes of payload to open it.
QuicStreamFrame data1(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece("HT"));
+ quiche::QuicheStringPiece("HT"));
session_->OnStreamFrame(data1);
EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams());
@@ -294,7 +295,7 @@
// Send two bytes of payload.
QuicStreamFrame data1(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece("HT"));
+ quiche::QuicheStringPiece("HT"));
session_->OnStreamFrame(data1);
// The stream should never be opened, now that the reset is received.
@@ -305,9 +306,9 @@
TEST_P(QuicServerSessionBaseTest, AcceptClosedStream) {
// Send (empty) compressed headers followed by two bytes of data.
QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece("\1\0\0\0\0\0\0\0HT"));
+ quiche::QuicheStringPiece("\1\0\0\0\0\0\0\0HT"));
QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(1), false, 0,
- QuicStringPiece("\2\0\0\0\0\0\0\0HT"));
+ quiche::QuicheStringPiece("\2\0\0\0\0\0\0\0HT"));
session_->OnStreamFrame(frame1);
session_->OnStreamFrame(frame2);
EXPECT_EQ(2u, session_->GetNumOpenIncomingStreams());
@@ -336,9 +337,9 @@
// past the reset point of stream 3. As it's a closed stream we just drop the
// data on the floor, but accept the packet because it has data for stream 5.
QuicStreamFrame frame3(GetNthClientInitiatedBidirectionalId(0), false, 2,
- QuicStringPiece("TP"));
+ quiche::QuicheStringPiece("TP"));
QuicStreamFrame frame4(GetNthClientInitiatedBidirectionalId(1), false, 2,
- QuicStringPiece("TP"));
+ quiche::QuicheStringPiece("TP"));
session_->OnStreamFrame(frame3);
session_->OnStreamFrame(frame4);
// The stream should never be opened, now that the reset is received.
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index 685ffc7..d699c85 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -17,7 +17,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/mock_quic_spdy_client_stream.h"
@@ -28,6 +27,8 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_session_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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"
using spdy::SpdyHeaderBlock;
using testing::_;
@@ -427,7 +428,7 @@
connection_->transport_version(), 3);
char type[] = {0x00};
- QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+ QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
session_->OnStreamFrame(data1);
} else {
id = QuicUtils::GetHeadersStreamId(connection_->transport_version());
@@ -457,7 +458,7 @@
connection_->transport_version(), 3);
char type[] = {0x00};
- QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+ QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
session_->OnStreamFrame(data1);
} else {
id = QuicUtils::GetHeadersStreamId(connection_->transport_version());
@@ -744,7 +745,7 @@
TEST_P(QuicSpdyClientSessionTest, ReceivingPromiseEnhanceYourCalm) {
for (size_t i = 0u; i < session_->get_max_promises(); i++) {
- push_promise_[":path"] = QuicStringPrintf("/bar%zu", i);
+ push_promise_[":path"] = quiche::QuicheStringPrintf("/bar%zu", i);
QuicStreamId id =
promised_stream_id_ +
@@ -762,7 +763,7 @@
// One more promise, this should be refused.
int i = session_->get_max_promises();
- push_promise_[":path"] = QuicStringPrintf("/bar%d", i);
+ push_promise_[":path"] = quiche::QuicheStringPrintf("/bar%d", i);
QuicStreamId id =
promised_stream_id_ +
@@ -922,7 +923,7 @@
connection_->transport_version(), promise_count);
auto headers = QuicHeaderList();
headers.OnHeaderBlockStart();
- headers.OnHeader(":path", QuicStrCat("/", promise_count));
+ headers.OnHeader(":path", quiche::QuicheStrCat("/", promise_count));
headers.OnHeader(":authority", "www.google.com");
headers.OnHeader(":method", "GET");
headers.OnHeader(":scheme", "https");
diff --git a/quic/core/http/quic_spdy_client_stream.cc b/quic/core/http/quic_spdy_client_stream.cc
index 5cbb79d..7232f76 100644
--- a/quic/core/http/quic_spdy_client_stream.cc
+++ b/quic/core/http/quic_spdy_client_stream.cc
@@ -11,6 +11,7 @@
#include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
#include "net/third_party/quiche/src/quic/core/quic_alarm.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
using spdy::SpdyHeaderBlock;
@@ -140,7 +141,7 @@
}
size_t QuicSpdyClientStream::SendRequest(SpdyHeaderBlock headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin) {
QuicConnection::ScopedPacketFlusher flusher(session_->connection());
bool send_fin_with_headers = fin && body.empty();
diff --git a/quic/core/http/quic_spdy_client_stream.h b/quic/core/http/quic_spdy_client_stream.h
index 5cd27d4..dfb9270 100644
--- a/quic/core/http/quic_spdy_client_stream.h
+++ b/quic/core/http/quic_spdy_client_stream.h
@@ -10,7 +10,7 @@
#include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream.h"
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/spdy_framer.h"
namespace quic {
@@ -52,7 +52,7 @@
// Serializes the headers and body, sends it to the server, and
// returns the number of bytes sent.
size_t SendRequest(spdy::SpdyHeaderBlock headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin);
// Returns the response data.
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index 8c1501e..50224cb 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -14,10 +14,10 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
using spdy::SpdyHeaderBlock;
using testing::_;
@@ -212,7 +212,7 @@
SpdyHeaderBlock trailer_block;
trailer_block["trailer key"] = "trailer value";
trailer_block[kFinalOffsetHeaderKey] =
- QuicTextUtils::Uint64ToString(body_.size());
+ quiche::QuicheTextUtils::Uint64ToString(body_.size());
auto trailers = AsHeaderList(trailer_block);
stream_->OnStreamHeaderList(true, trailers.uncompressed_header_bytes(),
trailers);
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 2d38f86..23c0c63 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -22,8 +22,9 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_stack_trace.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.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"
#include "net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.h"
using http2::Http2DecoderAdapter;
@@ -145,10 +146,10 @@
default:
break;
}
- CloseConnection(
- QuicStrCat("SPDY framing error: ",
- Http2DecoderAdapter::SpdyFramerErrorToString(error)),
- code);
+ CloseConnection(quiche::QuicheStrCat(
+ "SPDY framing error: ",
+ Http2DecoderAdapter::SpdyFramerErrorToString(error)),
+ code);
}
void OnDataFrameHeader(SpdyStreamId /*stream_id*/,
@@ -414,20 +415,22 @@
2 * max_inbound_header_list_size_);
}
-void QuicSpdySession::OnDecoderStreamError(QuicStringPiece error_message) {
+void QuicSpdySession::OnDecoderStreamError(
+ quiche::QuicheStringPiece error_message) {
DCHECK(VersionUsesHttp3(transport_version()));
CloseConnectionWithDetails(
QUIC_QPACK_DECODER_STREAM_ERROR,
- QuicStrCat("Decoder stream error: ", error_message));
+ quiche::QuicheStrCat("Decoder stream error: ", error_message));
}
-void QuicSpdySession::OnEncoderStreamError(QuicStringPiece error_message) {
+void QuicSpdySession::OnEncoderStreamError(
+ quiche::QuicheStringPiece error_message) {
DCHECK(VersionUsesHttp3(transport_version()));
CloseConnectionWithDetails(
QUIC_QPACK_ENCODER_STREAM_ERROR,
- QuicStrCat("Encoder stream error: ", error_message));
+ quiche::QuicheStrCat("Encoder stream error: ", error_message));
}
void QuicSpdySession::OnStreamHeadersPriority(
@@ -460,7 +463,8 @@
const std::string& header_key = header.first;
const std::string& header_value = header.second;
if (header_key == kFinalOffsetHeaderKey) {
- if (!QuicTextUtils::StringToSizeT(header_value, &final_byte_offset)) {
+ if (!quiche::QuicheTextUtils::StringToSizeT(header_value,
+ &final_byte_offset)) {
connection()->CloseConnection(
QUIC_INVALID_HEADERS_STREAM_DATA,
"Trailers are malformed (no final offset)",
@@ -523,7 +527,7 @@
SpdyPriorityIR priority_frame(id, parent_stream_id, weight, exclusive);
SpdySerializedFrame frame(spdy_framer_.SerializeFrame(priority_frame));
headers_stream()->WriteOrBufferData(
- QuicStringPiece(frame.data(), frame.size()), false, nullptr);
+ quiche::QuicheStringPiece(frame.data(), frame.size()), false, nullptr);
return frame.size();
}
@@ -581,7 +585,7 @@
SpdySerializedFrame frame(spdy_framer_.SerializeFrame(push_promise));
headers_stream()->WriteOrBufferData(
- QuicStringPiece(frame.data(), frame.size()), false, nullptr);
+ quiche::QuicheStringPiece(frame.data(), frame.size()), false, nullptr);
return;
}
@@ -628,7 +632,8 @@
if (stream && stream->is_static()) {
QUIC_BUG << "GetOrCreateSpdyDataStream returns static stream " << stream_id;
connection()->CloseConnection(
- QUIC_INVALID_STREAM_ID, QuicStrCat("stream ", stream_id, " is static"),
+ QUIC_INVALID_STREAM_ID,
+ quiche::QuicheStrCat("stream ", stream_id, " is static"),
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
return nullptr;
}
@@ -681,7 +686,7 @@
}
SpdySerializedFrame frame(spdy_framer_.SerializeFrame(headers_frame));
headers_stream()->WriteOrBufferData(
- QuicStringPiece(frame.data(), frame.size()), false,
+ quiche::QuicheStringPiece(frame.data(), frame.size()), false,
std::move(ack_listener));
// Calculate compressed header block size without framing overhead.
@@ -766,7 +771,8 @@
if (IsConnected()) {
CloseConnectionWithDetails(
QUIC_INVALID_HEADERS_STREAM_DATA,
- QuicStrCat("Invalid value for SETTINGS_ENABLE_PUSH: ", value));
+ quiche::QuicheStrCat("Invalid value for SETTINGS_ENABLE_PUSH: ",
+ value));
}
return;
}
@@ -782,7 +788,8 @@
if (IsConnected()) {
CloseConnectionWithDetails(
QUIC_INVALID_HEADERS_STREAM_DATA,
- QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ", id));
+ quiche::QuicheStrCat(
+ "Unsupported field of HTTP/2 SETTINGS frame: ", id));
}
}
break;
@@ -799,7 +806,8 @@
if (IsConnected()) {
CloseConnectionWithDetails(
QUIC_INVALID_HEADERS_STREAM_DATA,
- QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ", id));
+ quiche::QuicheStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
+ id));
}
}
}
@@ -1062,12 +1070,13 @@
}
void QuicSpdySession::CloseConnectionOnDuplicateHttp3UnidirectionalStreams(
- QuicStringPiece type) {
- QUIC_PEER_BUG << QuicStrCat("Received a duplicate ", type,
- " stream: Closing connection.");
+ quiche::QuicheStringPiece type) {
+ QUIC_PEER_BUG << quiche::QuicheStrCat("Received a duplicate ", type,
+ " stream: Closing connection.");
// TODO(b/124216424): Change to HTTP_STREAM_CREATION_ERROR.
- CloseConnectionWithDetails(QUIC_INVALID_STREAM_ID,
- QuicStrCat(type, " stream is received twice."));
+ CloseConnectionWithDetails(
+ QUIC_INVALID_STREAM_ID,
+ quiche::QuicheStrCat(type, " stream is received twice."));
}
// static
diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index 7e952c5..032ee12 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -24,7 +24,7 @@
#include "net/third_party/quiche/src/quic/core/quic_session.h"
#include "net/third_party/quiche/src/quic/core/quic_versions.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.h"
namespace quic {
@@ -95,10 +95,10 @@
void Initialize() override;
// QpackEncoder::DecoderStreamErrorDelegate implementation.
- void OnDecoderStreamError(QuicStringPiece error_message) override;
+ void OnDecoderStreamError(quiche::QuicheStringPiece error_message) override;
// QpackDecoder::EncoderStreamErrorDelegate implementation.
- void OnEncoderStreamError(QuicStringPiece error_message) override;
+ void OnEncoderStreamError(quiche::QuicheStringPiece error_message) override;
// Called by |headers_stream_| when headers with a priority have been
// received for a stream. This method will only be called for server streams.
@@ -363,7 +363,7 @@
const spdy::SpdyStreamPrecedence& precedence);
void CloseConnectionOnDuplicateHttp3UnidirectionalStreams(
- QuicStringPiece type);
+ quiche::QuicheStringPiece type);
// Sends any data which should be sent at the start of a connection,
// including the initial SETTINGS frame, etc.
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index bf5004e..7503593 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -26,10 +26,7 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_encoder_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_header_table_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
@@ -42,6 +39,9 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_send_buffer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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_text_utils.h"
#include "net/third_party/quiche/src/spdy/core/spdy_framer.h"
using spdy::kV3HighestPriority;
@@ -627,8 +627,8 @@
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_, OnStreamReset(closed_stream_id, _));
stream2->Reset(QUIC_BAD_APPLICATION_PAYLOAD);
- std::string msg =
- QuicStrCat("Marking unknown stream ", closed_stream_id, " blocked.");
+ std::string msg = quiche::QuicheStrCat("Marking unknown stream ",
+ closed_stream_id, " blocked.");
EXPECT_QUIC_BUG(session_.MarkConnectionLevelWriteBlocked(closed_stream_id),
msg);
}
@@ -1085,7 +1085,7 @@
TEST_P(QuicSpdySessionTestServer, RstStreamBeforeHeadersDecompressed) {
// Send two bytes of payload.
QuicStreamFrame data1(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece("HT"));
+ quiche::QuicheStringPiece("HT"));
session_.OnStreamFrame(data1);
EXPECT_EQ(1u, session_.GetNumOpenIncomingStreams());
@@ -1129,14 +1129,14 @@
id = GetNthClientInitiatedUnidirectionalStreamId(transport_version(), 3);
char type[] = {kControlStream};
- QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+ QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
session_.OnStreamFrame(data1);
} else {
id = QuicUtils::GetHeadersStreamId(transport_version());
}
// Send two bytes of payload.
- QuicStreamFrame data1(id, true, 0, QuicStringPiece("HT"));
+ QuicStreamFrame data1(id, true, 0, quiche::QuicheStringPiece("HT"));
EXPECT_CALL(*connection_,
CloseConnection(
QUIC_INVALID_STREAM_ID, "Attempt to close a static stream",
@@ -1151,7 +1151,7 @@
id = GetNthClientInitiatedUnidirectionalStreamId(transport_version(), 3);
char type[] = {kControlStream};
- QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+ QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
session_.OnStreamFrame(data1);
} else {
id = QuicUtils::GetHeadersStreamId(transport_version());
@@ -1170,7 +1170,7 @@
TEST_P(QuicSpdySessionTestServer, OnStreamFrameInvalidStreamId) {
// Send two bytes of payload.
QuicStreamFrame data1(QuicUtils::GetInvalidStreamId(transport_version()),
- true, 0, QuicStringPiece("HT"));
+ true, 0, quiche::QuicheStringPiece("HT"));
EXPECT_CALL(*connection_,
CloseConnection(
QUIC_INVALID_STREAM_ID, "Received data for an invalid stream",
@@ -1320,8 +1320,8 @@
while (!headers_stream->flow_controller()->IsBlocked() && stream_id < 2000) {
EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
- headers["header"] = QuicStrCat(random.RandUint64(), random.RandUint64(),
- random.RandUint64());
+ headers["header"] = quiche::QuicheStrCat(
+ random.RandUint64(), random.RandUint64(), random.RandUint64());
session_.WriteHeadersOnHeadersStream(stream_id, headers.Clone(), true,
spdy::SpdyStreamPrecedence(0),
nullptr);
@@ -1447,7 +1447,8 @@
// account the total number of bytes sent by the peer.
const QuicStreamOffset kByteOffset = 5678;
std::string body = "hello";
- QuicStreamFrame frame(stream->id(), true, kByteOffset, QuicStringPiece(body));
+ QuicStreamFrame frame(stream->id(), true, kByteOffset,
+ quiche::QuicheStringPiece(body));
session_.OnStreamFrame(frame);
QuicStreamOffset total_stream_bytes_sent_by_peer =
@@ -1564,7 +1565,8 @@
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_, OnStreamReset(stream->id(), _));
stream->Reset(QUIC_STREAM_CANCELLED);
- QuicStreamFrame frame(stream->id(), true, kLargeOffset, QuicStringPiece());
+ QuicStreamFrame frame(stream->id(), true, kLargeOffset,
+ quiche::QuicheStringPiece());
session_.OnStreamFrame(frame);
// Check that RST results in connection close.
@@ -1630,7 +1632,7 @@
// FIN or a RST_STREAM from the client.
const QuicStreamId kNextId = QuicUtils::StreamIdDelta(transport_version());
for (QuicStreamId i = kFirstStreamId; i < kFinalStreamId; i += kNextId) {
- QuicStreamFrame data1(i, false, 0, QuicStringPiece("HT"));
+ QuicStreamFrame data1(i, false, 0, quiche::QuicheStringPiece("HT"));
session_.OnStreamFrame(data1);
// EXPECT_EQ(1u, session_.GetNumOpenStreams());
if (!VersionHasIetfQuicFrames(transport_version())) {
@@ -1666,7 +1668,8 @@
_));
}
// Create one more data streams to exceed limit of open stream.
- QuicStreamFrame data1(kFinalStreamId, false, 0, QuicStringPiece("HT"));
+ QuicStreamFrame data1(kFinalStreamId, false, 0,
+ quiche::QuicheStringPiece("HT"));
session_.OnStreamFrame(data1);
}
@@ -1701,7 +1704,7 @@
const QuicStreamId kFinalStreamId =
GetNthClientInitiatedBidirectionalId(kMaxStreams + 1);
for (QuicStreamId i = kFirstStreamId; i < kFinalStreamId; i += IdDelta()) {
- QuicStreamFrame data1(i, true, 0, QuicStringPiece("HT"));
+ QuicStreamFrame data1(i, true, 0, quiche::QuicheStringPiece("HT"));
session_.OnStreamFrame(data1);
EXPECT_EQ(1u, session_.GetNumOpenIncomingStreams());
session_.StreamDraining(i);
@@ -1815,7 +1818,7 @@
QuicStreamPeer::CloseReadSide(stream);
// Receive a stream data frame with FIN.
- QuicStreamFrame frame(stream_id, true, 0, QuicStringPiece());
+ QuicStreamFrame frame(stream_id, true, 0, quiche::QuicheStringPiece());
session_.OnStreamFrame(frame);
EXPECT_TRUE(stream->fin_received());
@@ -1869,8 +1872,8 @@
const QuicMemSlice& slice =
QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer)->slice;
- EXPECT_EQ(QuicStringPiece(frame.data(), frame.size()),
- QuicStringPiece(slice.data(), slice.length()));
+ EXPECT_EQ(quiche::QuicheStringPiece(frame.data(), frame.size()),
+ quiche::QuicheStringPiece(slice.data(), slice.length()));
}
TEST_P(QuicSpdySessionTestClient, Http3ServerPush) {
@@ -1881,7 +1884,7 @@
EXPECT_EQ(0u, session_.GetNumOpenIncomingStreams());
// Push unidirectional stream is type 0x01.
- std::string frame_type1 = QuicTextUtils::HexDecode("01");
+ std::string frame_type1 = quiche::QuicheTextUtils::HexDecode("01");
QuicStreamId stream_id1 =
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
session_.OnStreamFrame(QuicStreamFrame(stream_id1, /* fin = */ false,
@@ -1893,7 +1896,7 @@
EXPECT_EQ(1u, session_.flow_controller()->bytes_consumed());
// The same stream type can be encoded differently.
- std::string frame_type2 = QuicTextUtils::HexDecode("80000001");
+ std::string frame_type2 = quiche::QuicheTextUtils::HexDecode("80000001");
QuicStreamId stream_id2 =
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 1);
session_.OnStreamFrame(QuicStreamFrame(stream_id2, /* fin = */ false,
@@ -1913,9 +1916,9 @@
EXPECT_EQ(0u, session_.GetNumOpenIncomingStreams());
// Push unidirectional stream is type 0x01.
- std::string frame_type = QuicTextUtils::HexDecode("01");
+ std::string frame_type = quiche::QuicheTextUtils::HexDecode("01");
// The first field of a push stream is the Push ID.
- std::string push_id = QuicTextUtils::HexDecode("4000");
+ std::string push_id = quiche::QuicheTextUtils::HexDecode("4000");
QuicStreamId stream_id =
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
@@ -2120,7 +2123,7 @@
char input[] = {0x04, // type
'a', 'b', 'c'}; // data
- QuicStringPiece payload(input, QUIC_ARRAYSIZE(input));
+ quiche::QuicheStringPiece payload(input, QUIC_ARRAYSIZE(input));
// This is a server test with a client-initiated unidirectional stream.
QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
@@ -2156,7 +2159,7 @@
char input[] = {0x04, // type
'a', 'b', 'c'}; // data
- QuicStringPiece payload(input, QUIC_ARRAYSIZE(input));
+ quiche::QuicheStringPiece payload(input, QUIC_ARRAYSIZE(input));
// This is a server test with a client-initiated unidirectional stream.
QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
@@ -2197,7 +2200,7 @@
char input[] = {0x41, 0x00, // type (256)
'a', 'b', 'c'}; // data
- QuicStringPiece payload(input, QUIC_ARRAYSIZE(input));
+ quiche::QuicheStringPiece payload(input, QUIC_ARRAYSIZE(input));
// This is a server test with a client-initiated unidirectional stream.
QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
@@ -2244,7 +2247,8 @@
GetNthClientInitiatedUnidirectionalStreamId(transport_version(), 3);
char type[] = {kControlStream};
- QuicStreamFrame data1(stream_id, false, 0, QuicStringPiece(type, 1));
+ QuicStreamFrame data1(stream_id, false, 0,
+ quiche::QuicheStringPiece(type, 1));
EXPECT_CALL(debug_visitor, OnPeerControlStreamCreated(stream_id)).Times(0);
session_.OnStreamFrame(data1);
EXPECT_EQ(stream_id,
@@ -2256,7 +2260,7 @@
settings.values[SETTINGS_MAX_HEADER_LIST_SIZE] = 5;
settings.values[SETTINGS_QPACK_BLOCKED_STREAMS] = 42;
std::string data = EncodeSettings(settings);
- QuicStreamFrame frame(stream_id, false, 1, QuicStringPiece(data));
+ QuicStreamFrame frame(stream_id, false, 1, quiche::QuicheStringPiece(data));
QpackEncoder* qpack_encoder = session_.qpack_encoder();
QpackHeaderTable* header_table =
@@ -2289,8 +2293,9 @@
settings.values[SETTINGS_MAX_HEADER_LIST_SIZE] = 5;
std::string data = EncodeSettings(settings);
- QuicStreamFrame data1(stream_id, false, 1, QuicStringPiece(data));
- QuicStreamFrame data2(stream_id, false, 0, QuicStringPiece(type, 1));
+ QuicStreamFrame data1(stream_id, false, 1, quiche::QuicheStringPiece(data));
+ QuicStreamFrame data2(stream_id, false, 0,
+ quiche::QuicheStringPiece(type, 1));
session_.OnStreamFrame(data1);
EXPECT_NE(5u, session_.max_outbound_header_list_size());
@@ -2310,14 +2315,15 @@
TestStream* stream = session_.CreateIncomingStream(stream_id);
// HEADERS frame referencing first dynamic table entry.
- std::string headers_payload = QuicTextUtils::HexDecode("020080");
+ std::string headers_payload = quiche::QuicheTextUtils::HexDecode("020080");
std::unique_ptr<char[]> headers_buffer;
QuicByteCount headers_frame_header_length =
HttpEncoder::SerializeHeadersFrameHeader(headers_payload.length(),
&headers_buffer);
- QuicStringPiece headers_frame_header(headers_buffer.get(),
- headers_frame_header_length);
- std::string headers = QuicStrCat(headers_frame_header, headers_payload);
+ quiche::QuicheStringPiece headers_frame_header(headers_buffer.get(),
+ headers_frame_header_length);
+ std::string headers =
+ quiche::QuicheStrCat(headers_frame_header, headers_payload);
stream->OnStreamFrame(QuicStreamFrame(stream_id, false, 0, headers));
// Decoding is blocked because dynamic table entry has not been received yet.
@@ -2344,14 +2350,15 @@
TestStream* stream = session_.CreateIncomingStream(stream_id);
// HEADERS frame referencing first dynamic table entry.
- std::string headers_payload = QuicTextUtils::HexDecode("020080");
+ std::string headers_payload = quiche::QuicheTextUtils::HexDecode("020080");
std::unique_ptr<char[]> headers_buffer;
QuicByteCount headers_frame_header_length =
HttpEncoder::SerializeHeadersFrameHeader(headers_payload.length(),
&headers_buffer);
- QuicStringPiece headers_frame_header(headers_buffer.get(),
- headers_frame_header_length);
- std::string headers = QuicStrCat(headers_frame_header, headers_payload);
+ quiche::QuicheStringPiece headers_frame_header(headers_buffer.get(),
+ headers_frame_header_length);
+ std::string headers =
+ quiche::QuicheStrCat(headers_frame_header, headers_payload);
stream->OnStreamFrame(QuicStreamFrame(stream_id, false, 0, headers));
// Decoding is blocked because dynamic table entry has not been received yet.
@@ -2376,7 +2383,7 @@
// Payload consists of two bytes. The first byte is an unknown unidirectional
// stream type. The second one would be the type of a push stream, but it
// must not be interpreted as stream type.
- std::string payload = QuicTextUtils::HexDecode("3f01");
+ std::string payload = quiche::QuicheTextUtils::HexDecode("3f01");
QuicStreamFrame frame(stream_id, /* fin = */ false, /* offset = */ 0,
payload);
@@ -2422,7 +2429,7 @@
// Payload consists of two bytes. The first byte is an unknown unidirectional
// stream type. The second one would be the type of a push stream, but it
// must not be interpreted as stream type.
- std::string payload = QuicTextUtils::HexDecode("3f01");
+ std::string payload = quiche::QuicheTextUtils::HexDecode("3f01");
QuicStreamFrame frame(stream_id, /* fin = */ false, /* offset = */ 0,
payload);
@@ -2459,7 +2466,7 @@
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
// Payload is the first byte of a two byte varint encoding.
- std::string payload = QuicTextUtils::HexDecode("40");
+ std::string payload = quiche::QuicheTextUtils::HexDecode("40");
QuicStreamFrame frame(stream_id, /* fin = */ false, /* offset = */ 0,
payload);
@@ -2487,7 +2494,7 @@
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
// Payload is the first byte of a two byte varint encoding with a FIN.
- std::string payload = QuicTextUtils::HexDecode("40");
+ std::string payload = quiche::QuicheTextUtils::HexDecode("40");
QuicStreamFrame frame(stream_id, /* fin = */ true, /* offset = */ 0, payload);
session_.OnStreamFrame(frame);
@@ -2506,12 +2513,12 @@
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
char type1[] = {kControlStream};
- QuicStreamFrame data1(id1, false, 0, QuicStringPiece(type1, 1));
+ QuicStreamFrame data1(id1, false, 0, quiche::QuicheStringPiece(type1, 1));
EXPECT_CALL(debug_visitor, OnPeerControlStreamCreated(id1));
session_.OnStreamFrame(data1);
QuicStreamId id2 =
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 1);
- QuicStreamFrame data2(id2, false, 0, QuicStringPiece(type1, 1));
+ QuicStreamFrame data2(id2, false, 0, quiche::QuicheStringPiece(type1, 1));
EXPECT_CALL(debug_visitor, OnPeerControlStreamCreated(id2)).Times(0);
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID,
@@ -2524,13 +2531,13 @@
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 2);
char type2[]{kQpackEncoderStream};
- QuicStreamFrame data3(id3, false, 0, QuicStringPiece(type2, 1));
+ QuicStreamFrame data3(id3, false, 0, quiche::QuicheStringPiece(type2, 1));
EXPECT_CALL(debug_visitor, OnPeerQpackEncoderStreamCreated(id3));
session_.OnStreamFrame(data3);
QuicStreamId id4 =
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 3);
- QuicStreamFrame data4(id4, false, 0, QuicStringPiece(type2, 1));
+ QuicStreamFrame data4(id4, false, 0, quiche::QuicheStringPiece(type2, 1));
EXPECT_CALL(debug_visitor, OnPeerQpackEncoderStreamCreated(id4)).Times(0);
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID,
@@ -2543,13 +2550,13 @@
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 4);
char type3[]{kQpackDecoderStream};
- QuicStreamFrame data5(id5, false, 0, QuicStringPiece(type3, 1));
+ QuicStreamFrame data5(id5, false, 0, quiche::QuicheStringPiece(type3, 1));
EXPECT_CALL(debug_visitor, OnPeerQpackDecoderStreamCreated(id5));
session_.OnStreamFrame(data5);
QuicStreamId id6 =
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 5);
- QuicStreamFrame data6(id6, false, 0, QuicStringPiece(type3, 1));
+ QuicStreamFrame data6(id6, false, 0, quiche::QuicheStringPiece(type3, 1));
EXPECT_CALL(debug_visitor, OnPeerQpackDecoderStreamCreated(id6)).Times(0);
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID,
@@ -2564,7 +2571,7 @@
return;
}
- std::string data = QuicTextUtils::HexDecode(
+ std::string data = quiche::QuicheTextUtils::HexDecode(
"02" // Encoder stream.
"00"); // Duplicate entry 0, but no entries exist.
@@ -2585,7 +2592,7 @@
return;
}
- std::string data = QuicTextUtils::HexDecode(
+ std::string data = quiche::QuicheTextUtils::HexDecode(
"03" // Decoder stream.
"00"); // Insert Count Increment with forbidden increment value of zero.
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index bf1f127..a65e964 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -23,8 +23,8 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_storage.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.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"
#include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
using spdy::SpdyHeaderBlock;
@@ -91,7 +91,7 @@
return stream_->OnDataFrameStart(header_length);
}
- bool OnDataFramePayload(QuicStringPiece payload) override {
+ bool OnDataFramePayload(quiche::QuicheStringPiece payload) override {
DCHECK(!payload.empty());
return stream_->OnDataFramePayload(payload);
}
@@ -106,7 +106,7 @@
return stream_->OnHeadersFrameStart(header_length);
}
- bool OnHeadersFramePayload(QuicStringPiece payload) override {
+ bool OnHeadersFramePayload(quiche::QuicheStringPiece payload) override {
DCHECK(!payload.empty());
if (!VersionUsesHttp3(stream_->transport_version())) {
CloseConnectionOnWrongFrame("Headers");
@@ -140,7 +140,7 @@
return stream_->OnPushPromiseFramePushId(push_id, push_id_length);
}
- bool OnPushPromiseFramePayload(QuicStringPiece payload) override {
+ bool OnPushPromiseFramePayload(quiche::QuicheStringPiece payload) override {
DCHECK(!payload.empty());
if (!VersionUsesHttp3(stream_->transport_version())) {
CloseConnectionOnWrongFrame("Push Promise");
@@ -162,17 +162,17 @@
return stream_->OnUnknownFrameStart(frame_type, header_length);
}
- bool OnUnknownFramePayload(QuicStringPiece payload) override {
+ bool OnUnknownFramePayload(quiche::QuicheStringPiece payload) override {
return stream_->OnUnknownFramePayload(payload);
}
bool OnUnknownFrameEnd() override { return stream_->OnUnknownFrameEnd(); }
private:
- void CloseConnectionOnWrongFrame(QuicStringPiece frame_type) {
+ void CloseConnectionOnWrongFrame(quiche::QuicheStringPiece frame_type) {
stream_->session()->connection()->CloseConnection(
QUIC_HTTP_DECODER_ERROR,
- QuicStrCat(frame_type, " frame received on data stream"),
+ quiche::QuicheStrCat(frame_type, " frame received on data stream"),
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
}
@@ -273,8 +273,8 @@
QUIC_LOG(INFO) << ENDPOINT << "Stream " << id()
<< " is writing type as server push";
- WriteOrBufferData(QuicStringPiece(writer.data(), writer.length()), false,
- nullptr);
+ WriteOrBufferData(quiche::QuicheStringPiece(writer.data(), writer.length()),
+ false, nullptr);
}
size_t bytes_written =
WriteHeadersImpl(std::move(header_block), fin, std::move(ack_listener));
@@ -289,7 +289,8 @@
return bytes_written;
}
-void QuicSpdyStream::WriteOrBufferBody(QuicStringPiece data, bool fin) {
+void QuicSpdyStream::WriteOrBufferBody(quiche::QuicheStringPiece data,
+ bool fin) {
if (!VersionUsesHttp3(transport_version()) || data.length() == 0) {
WriteOrBufferData(data, fin, nullptr);
return;
@@ -306,8 +307,8 @@
QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id()
<< " is writing DATA frame header of length "
<< header_length;
- WriteOrBufferData(QuicStringPiece(buffer.get(), header_length), false,
- nullptr);
+ WriteOrBufferData(quiche::QuicheStringPiece(buffer.get(), header_length),
+ false, nullptr);
// Write body.
QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id()
@@ -331,8 +332,9 @@
stream_bytes_written() + BufferedDataBytes();
QUIC_DLOG(INFO) << ENDPOINT << "Inserting trailer: ("
<< kFinalOffsetHeaderKey << ", " << final_offset << ")";
- trailer_block.insert(std::make_pair(
- kFinalOffsetHeaderKey, QuicTextUtils::Uint64ToString(final_offset)));
+ trailer_block.insert(
+ std::make_pair(kFinalOffsetHeaderKey,
+ quiche::QuicheTextUtils::Uint64ToString(final_offset)));
}
// Write the trailing headers with a FIN, and close stream for writing:
@@ -373,8 +375,8 @@
<< " is writing Push Promise frame header of length "
<< push_promise_frame_length << " , with promised id "
<< frame.push_id;
- WriteOrBufferData(QuicStringPiece(push_promise_frame_with_id.get(),
- push_promise_frame_length),
+ WriteOrBufferData(quiche::QuicheStringPiece(push_promise_frame_with_id.get(),
+ push_promise_frame_length),
/* fin = */ false, /* ack_listener = */ nullptr);
// Write response headers.
@@ -565,10 +567,11 @@
}
}
-void QuicSpdyStream::OnHeaderDecodingError(QuicStringPiece error_message) {
+void QuicSpdyStream::OnHeaderDecodingError(
+ quiche::QuicheStringPiece error_message) {
qpack_decoded_headers_accumulator_.reset();
- std::string connection_close_error_message = QuicStrCat(
+ std::string connection_close_error_message = quiche::QuicheStrCat(
"Error decoding ", headers_decompressed_ ? "trailers" : "headers",
" on stream ", id(), ": ", error_message);
CloseConnectionWithDetails(QUIC_QPACK_DECOMPRESSION_FAILED,
@@ -580,7 +583,7 @@
// TODO(b/124216424): Reset stream with H3_REQUEST_CANCELLED (if client)
// or with H3_REQUEST_REJECTED (if server).
std::string error_message =
- QuicStrCat("Too large headers received on stream ", id());
+ quiche::QuicheStrCat("Too large headers received on stream ", id());
CloseConnectionWithDetails(QUIC_HEADERS_STREAM_DATA_DECOMPRESS_FAILURE,
error_message);
} else {
@@ -601,14 +604,14 @@
OnStreamFrame(
QuicStreamFrame(id(), /* fin = */ true,
flow_controller()->highest_received_byte_offset(),
- QuicStringPiece()));
+ quiche::QuicheStringPiece()));
}
return;
}
if (fin && !rst_sent()) {
- OnStreamFrame(
- QuicStreamFrame(id(), fin, /* offset = */ 0, QuicStringPiece()));
+ OnStreamFrame(QuicStreamFrame(id(), fin, /* offset = */ 0,
+ quiche::QuicheStringPiece()));
}
if (FinishedReadingHeaders()) {
sequencer()->SetUnblocked();
@@ -668,7 +671,8 @@
VersionUsesHttp3(transport_version())
? flow_controller()->highest_received_byte_offset()
: final_byte_offset;
- OnStreamFrame(QuicStreamFrame(id(), fin, offset, QuicStringPiece()));
+ OnStreamFrame(
+ QuicStreamFrame(id(), fin, offset, quiche::QuicheStringPiece()));
}
}
@@ -794,7 +798,7 @@
if (it == header.end()) {
return false;
}
- const QuicStringPiece status(it->second);
+ const quiche::QuicheStringPiece status(it->second);
if (status.size() != 3) {
return false;
}
@@ -806,7 +810,7 @@
if (!isdigit(status[1]) || !isdigit(status[2])) {
return false;
}
- return QuicTextUtils::StringToInt(status, status_code);
+ return quiche::QuicheTextUtils::StringToInt(status, status_code);
}
bool QuicSpdyStream::FinishedReadingTrailers() const {
@@ -840,7 +844,7 @@
return true;
}
-bool QuicSpdyStream::OnDataFramePayload(QuicStringPiece payload) {
+bool QuicSpdyStream::OnDataFramePayload(quiche::QuicheStringPiece payload) {
DCHECK(VersionUsesHttp3(transport_version()));
body_manager_.OnBody(payload);
@@ -926,7 +930,7 @@
return true;
}
-bool QuicSpdyStream::OnHeadersFramePayload(QuicStringPiece payload) {
+bool QuicSpdyStream::OnHeadersFramePayload(quiche::QuicheStringPiece payload) {
DCHECK(VersionUsesHttp3(transport_version()));
DCHECK(qpack_decoded_headers_accumulator_);
@@ -989,7 +993,8 @@
return true;
}
-bool QuicSpdyStream::OnPushPromiseFramePayload(QuicStringPiece payload) {
+bool QuicSpdyStream::OnPushPromiseFramePayload(
+ quiche::QuicheStringPiece payload) {
spdy_session_->OnCompressedFrameSize(payload.length());
return OnHeadersFramePayload(payload);
}
@@ -1010,7 +1015,7 @@
return true;
}
-bool QuicSpdyStream::OnUnknownFramePayload(QuicStringPiece payload) {
+bool QuicSpdyStream::OnUnknownFramePayload(quiche::QuicheStringPiece payload) {
// Ignore unknown frames, but consume frame payload.
QUIC_DVLOG(1) << ENDPOINT << "Discarding " << payload.size()
<< " bytes of payload of frame of unknown type.";
@@ -1058,9 +1063,9 @@
QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id()
<< " is writing HEADERS frame header of length "
<< headers_frame_header_length;
- WriteOrBufferData(
- QuicStringPiece(headers_frame_header.get(), headers_frame_header_length),
- /* fin = */ false, /* ack_listener = */ nullptr);
+ WriteOrBufferData(quiche::QuicheStringPiece(headers_frame_header.get(),
+ headers_frame_header_length),
+ /* fin = */ false, /* ack_listener = */ nullptr);
QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id()
<< " is writing HEADERS frame payload of length "
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index c4333f3..9650744 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -26,6 +26,7 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/spdy_framer.h"
namespace quic {
@@ -121,7 +122,7 @@
QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
// Sends |data| to the peer, or buffers if it can't be sent immediately.
- void WriteOrBufferBody(QuicStringPiece data, bool fin);
+ void WriteOrBufferBody(quiche::QuicheStringPiece data, bool fin);
// Writes the trailers contained in |trailer_block| on the dedicated headers
// stream or on this stream, depending on VersionUsesHttp3(). Trailers will
@@ -216,7 +217,7 @@
// QpackDecodedHeadersAccumulator::Visitor implementation.
void OnHeadersDecoded(QuicHeaderList headers,
bool header_list_size_limit_exceeded) override;
- void OnHeaderDecodingError(QuicStringPiece error_message) override;
+ void OnHeaderDecodingError(quiche::QuicheStringPiece error_message) override;
protected:
// Called when the received headers are too large. By default this will
@@ -255,17 +256,17 @@
// Called by HttpDecoderVisitor.
bool OnDataFrameStart(QuicByteCount header_length);
- bool OnDataFramePayload(QuicStringPiece payload);
+ bool OnDataFramePayload(quiche::QuicheStringPiece payload);
bool OnDataFrameEnd();
bool OnHeadersFrameStart(QuicByteCount header_length);
- bool OnHeadersFramePayload(QuicStringPiece payload);
+ bool OnHeadersFramePayload(quiche::QuicheStringPiece payload);
bool OnHeadersFrameEnd();
bool OnPushPromiseFrameStart(QuicByteCount header_length);
bool OnPushPromiseFramePushId(PushId push_id, QuicByteCount push_id_length);
- bool OnPushPromiseFramePayload(QuicStringPiece payload);
+ bool OnPushPromiseFramePayload(quiche::QuicheStringPiece payload);
bool OnPushPromiseFrameEnd();
bool OnUnknownFrameStart(uint64_t frame_type, QuicByteCount header_length);
- bool OnUnknownFramePayload(QuicStringPiece payload);
+ bool OnUnknownFramePayload(quiche::QuicheStringPiece payload);
bool OnUnknownFrameEnd();
// Given the interval marked by [|offset|, |offset| + |data_length|), return
diff --git a/quic/core/http/quic_spdy_stream_body_manager.cc b/quic/core/http/quic_spdy_stream_body_manager.cc
index 798f551..1e36aa7 100644
--- a/quic/core/http/quic_spdy_stream_body_manager.cc
+++ b/quic/core/http/quic_spdy_stream_body_manager.cc
@@ -7,6 +7,7 @@
#include <algorithm>
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -27,7 +28,7 @@
return 0;
}
-void QuicSpdyStreamBodyManager::OnBody(QuicStringPiece body) {
+void QuicSpdyStreamBodyManager::OnBody(quiche::QuicheStringPiece body) {
DCHECK(!body.empty());
fragments_.push_back({body, 0});
@@ -45,7 +46,7 @@
}
Fragment& fragment = fragments_.front();
- const QuicStringPiece body = fragment.body;
+ const quiche::QuicheStringPiece body = fragment.body;
if (body.length() > remaining_bytes) {
// Consume leading |remaining_bytes| bytes of body.
@@ -77,7 +78,7 @@
size_t iov_filled = 0;
while (iov_filled < fragments_.size() && iov_filled < iov_len) {
- QuicStringPiece body = fragments_[iov_filled].body;
+ quiche::QuicheStringPiece body = fragments_[iov_filled].body;
iov[iov_filled].iov_base = const_cast<char*>(body.data());
iov[iov_filled].iov_len = body.size();
iov_filled++;
@@ -101,7 +102,7 @@
while (!fragments_.empty()) {
Fragment& fragment = fragments_.front();
- const QuicStringPiece body = fragment.body;
+ const quiche::QuicheStringPiece body = fragment.body;
const size_t bytes_to_copy =
std::min<size_t>(body.length(), dest_remaining);
diff --git a/quic/core/http/quic_spdy_stream_body_manager.h b/quic/core/http/quic_spdy_stream_body_manager.h
index 1942c26..ac22978 100644
--- a/quic/core/http/quic_spdy_stream_body_manager.h
+++ b/quic/core/http/quic_spdy_stream_body_manager.h
@@ -11,7 +11,7 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_iovec.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_macros.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -43,7 +43,7 @@
// Called when body is received. |body| is added to |fragments_|. The data
// pointed to by |body| must be kept alive until an OnBodyConsumed() or
// ReadBody() call consumes it. |body| must not be empty.
- void OnBody(QuicStringPiece body);
+ void OnBody(quiche::QuicheStringPiece body);
// Internally marks |num_bytes| of body consumed. |num_bytes| might be zero.
// Returns the number of bytes that the caller should mark consumed with the
@@ -79,7 +79,7 @@
// consumed as soon as all of the body fragment is read.
struct QUIC_EXPORT_PRIVATE Fragment {
// |body| must not be empty.
- QuicStringPiece body;
+ quiche::QuicheStringPiece body;
// Might be zero.
QuicByteCount trailing_non_body_byte_count;
};
diff --git a/quic/core/http/quic_spdy_stream_body_manager_test.cc b/quic/core/http/quic_spdy_stream_body_manager_test.cc
index 10b19f1..b9e63ab 100644
--- a/quic/core/http/quic_spdy_stream_body_manager_test.cc
+++ b/quic/core/http/quic_spdy_stream_body_manager_test.cc
@@ -12,6 +12,7 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -152,7 +153,7 @@
static_cast<size_t>(body_manager.PeekBody(&iovecs[0], iov_len)));
for (size_t iovec_index = 0; iovec_index < iovs_filled; ++iovec_index) {
EXPECT_EQ(frame_payloads[iovec_index],
- QuicStringPiece(
+ quiche::QuicheStringPiece(
static_cast<const char*>(iovecs[iovec_index].iov_base),
iovecs[iovec_index].iov_len));
}
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index efb34ac..c5dc417 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -19,9 +19,7 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_flow_controller_peer.h"
@@ -30,6 +28,8 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_spdy_stream_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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"
using spdy::kV3HighestPriority;
using spdy::kV3LowestPriority;
@@ -168,7 +168,8 @@
// Return QPACK-encoded header block without using the dynamic table.
std::string EncodeQpackHeaders(
- std::vector<std::pair<QuicStringPiece, QuicStringPiece>> headers) {
+ std::vector<std::pair<quiche::QuicheStringPiece,
+ quiche::QuicheStringPiece>> headers) {
SpdyHeaderBlock header_block;
for (const auto& header_field : headers) {
header_block.AppendValueOrAddHeader(header_field.first,
@@ -280,7 +281,8 @@
// Construct HEADERS frame with QPACK-encoded |headers| without using the
// dynamic table.
std::string HeadersFrame(
- std::vector<std::pair<QuicStringPiece, QuicStringPiece>> headers) {
+ std::vector<std::pair<quiche::QuicheStringPiece,
+ quiche::QuicheStringPiece>> headers) {
return HeadersFrame(EncodeQpackHeaders(headers));
}
@@ -291,26 +293,27 @@
}
// Construct HEADERS frame with given payload.
- std::string HeadersFrame(QuicStringPiece payload) {
+ std::string HeadersFrame(quiche::QuicheStringPiece payload) {
std::unique_ptr<char[]> headers_buffer;
QuicByteCount headers_frame_header_length =
HttpEncoder::SerializeHeadersFrameHeader(payload.length(),
&headers_buffer);
- QuicStringPiece headers_frame_header(headers_buffer.get(),
- headers_frame_header_length);
- return QuicStrCat(headers_frame_header, payload);
+ quiche::QuicheStringPiece headers_frame_header(headers_buffer.get(),
+ headers_frame_header_length);
+ return quiche::QuicheStrCat(headers_frame_header, payload);
}
- std::string DataFrame(QuicStringPiece payload) {
+ std::string DataFrame(quiche::QuicheStringPiece payload) {
std::unique_ptr<char[]> data_buffer;
QuicByteCount data_frame_header_length =
HttpEncoder::SerializeDataFrameHeader(payload.length(), &data_buffer);
- QuicStringPiece data_frame_header(data_buffer.get(),
- data_frame_header_length);
- return QuicStrCat(data_frame_header, payload);
+ quiche::QuicheStringPiece data_frame_header(data_buffer.get(),
+ data_frame_header_length);
+ return quiche::QuicheStrCat(data_frame_header, payload);
}
- std::string UnknownFrame(uint64_t frame_type, QuicStringPiece payload) {
+ std::string UnknownFrame(uint64_t frame_type,
+ quiche::QuicheStringPiece payload) {
std::string frame;
const size_t length = QuicDataWriter::GetVarInt62Len(frame_type) +
QuicDataWriter::GetVarInt62Len(payload.size()) +
@@ -498,7 +501,7 @@
EXPECT_EQ(headers, stream_->header_list());
stream_->ConsumeHeaderList();
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
EXPECT_CALL(*connection_, CloseConnection(QUIC_HTTP_DECODER_ERROR, _, _))
.WillOnce(
@@ -530,7 +533,7 @@
EXPECT_EQ(headers, stream_->header_list());
stream_->ConsumeHeaderList();
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
stream_->OnStreamFrame(frame);
EXPECT_EQ(QuicHeaderList(), stream_->header_list());
EXPECT_EQ(body, stream_->data());
@@ -547,10 +550,10 @@
stream_->ConsumeHeaderList();
for (size_t offset = 0; offset < data.size(); offset += fragment_size) {
size_t remaining_data = data.size() - offset;
- QuicStringPiece fragment(data.data() + offset,
- std::min(fragment_size, remaining_data));
+ quiche::QuicheStringPiece fragment(
+ data.data() + offset, std::min(fragment_size, remaining_data));
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false,
- offset, QuicStringPiece(fragment));
+ offset, quiche::QuicheStringPiece(fragment));
stream_->OnStreamFrame(frame);
}
ASSERT_EQ(body, stream_->data()) << "fragment_size: " << fragment_size;
@@ -567,15 +570,15 @@
ASSERT_EQ(headers, stream_->header_list());
stream_->ConsumeHeaderList();
- QuicStringPiece fragment1(data.data(), split_point);
+ quiche::QuicheStringPiece fragment1(data.data(), split_point);
QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(fragment1));
+ quiche::QuicheStringPiece(fragment1));
stream_->OnStreamFrame(frame1);
- QuicStringPiece fragment2(data.data() + split_point,
- data.size() - split_point);
+ quiche::QuicheStringPiece fragment2(data.data() + split_point,
+ data.size() - split_point);
QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(0), false,
- split_point, QuicStringPiece(fragment2));
+ split_point, quiche::QuicheStringPiece(fragment2));
stream_->OnStreamFrame(frame2);
ASSERT_EQ(body, stream_->data()) << "split_point: " << split_point;
@@ -590,7 +593,7 @@
ProcessHeaders(false, headers_);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
stream_->OnStreamFrame(frame);
stream_->ConsumeHeaderList();
@@ -613,7 +616,7 @@
ProcessHeaders(false, headers_);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
stream_->OnStreamFrame(frame);
stream_->ConsumeHeaderList();
char buffer[2048];
@@ -637,7 +640,7 @@
ProcessHeaders(false, headers_);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
stream_->OnStreamFrame(frame);
stream_->ConsumeHeaderList();
@@ -660,9 +663,9 @@
ProcessHeaders(false, headers_);
QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data1));
+ quiche::QuicheStringPiece(data1));
QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(0), false,
- data1.length(), QuicStringPiece(data2));
+ data1.length(), quiche::QuicheStringPiece(data2));
stream_->OnStreamFrame(frame1);
stream_->OnStreamFrame(frame2);
stream_->ConsumeHeaderList();
@@ -680,7 +683,7 @@
ProcessHeaders(false, headers_);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
stream_->OnStreamFrame(frame);
stream_->ConsumeHeaderList();
@@ -704,7 +707,7 @@
ProcessHeaders(false, headers_);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
stream_->OnStreamFrame(frame);
stream_->ConsumeHeaderList();
@@ -795,7 +798,7 @@
ProcessHeaders(false, headers_);
QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
stream_->OnStreamFrame(frame1);
EXPECT_EQ(
kWindow - (kWindow / 3) - header_length,
@@ -805,7 +808,8 @@
// half full. This should all be buffered, decreasing the receive window but
// not sending WINDOW_UPDATE.
QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(0), false,
- kWindow / 3 + header_length, QuicStringPiece(data));
+ kWindow / 3 + header_length,
+ quiche::QuicheStringPiece(data));
stream_->OnStreamFrame(frame2);
EXPECT_EQ(
kWindow - (2 * kWindow / 3) - 2 * header_length,
@@ -846,7 +850,7 @@
stream_->ConsumeHeaderList();
QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
stream_->OnStreamFrame(frame1);
EXPECT_EQ(
kWindow - (kWindow / 3) - header_length,
@@ -857,7 +861,8 @@
// offset and send a WINDOW_UPDATE. The result will be again an available
// window of kWindow bytes.
QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(0), false,
- kWindow / 3 + header_length, QuicStringPiece(data));
+ kWindow / 3 + header_length,
+ quiche::QuicheStringPiece(data));
EXPECT_CALL(*connection_, SendControlFrame(_));
stream_->OnStreamFrame(frame2);
EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowSize(
@@ -921,10 +926,10 @@
}
QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
stream_->OnStreamFrame(frame1);
QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(1), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
stream2_->OnStreamFrame(frame2);
// Now receive a further single byte on one stream - again this does not
@@ -932,7 +937,8 @@
// is over half full and thus a connection WINDOW_UPDATE is sent.
EXPECT_CALL(*connection_, SendControlFrame(_));
QuicStreamFrame frame3(GetNthClientInitiatedBidirectionalId(0), false,
- body.length() + header_length, QuicStringPiece(data2));
+ body.length() + header_length,
+ quiche::QuicheStringPiece(data2));
stream_->OnStreamFrame(frame3);
}
@@ -954,7 +960,7 @@
std::string body(kWindow + 1, 'a');
std::string data = UsesHttp3() ? DataFrame(body) : body;
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
EXPECT_CALL(*connection_,
CloseConnection(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _, _));
stream_->OnStreamFrame(frame);
@@ -994,7 +1000,7 @@
EXPECT_LT(data.size(), kStreamWindow);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece(data));
+ quiche::QuicheStringPiece(data));
EXPECT_CALL(*connection_,
CloseConnection(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _, _));
@@ -1094,7 +1100,7 @@
trailers_block["key2"] = "value2";
trailers_block["key3"] = "value3";
trailers_block[kFinalOffsetHeaderKey] =
- QuicTextUtils::Uint64ToString(data.size());
+ quiche::QuicheTextUtils::Uint64ToString(data.size());
QuicHeaderList trailers = ProcessHeaders(true, trailers_block);
@@ -1343,7 +1349,7 @@
// on the headers stream.
if (!UsesHttp3()) {
expected_trailers[kFinalOffsetHeaderKey] =
- QuicTextUtils::Uint64ToString(body.length() + header_length);
+ quiche::QuicheTextUtils::Uint64ToString(body.length() + header_length);
}
EXPECT_CALL(*stream_, WriteHeadersMock(true));
@@ -1786,7 +1792,8 @@
std::string trailers =
HeadersFrame({std::make_pair("custom-key", "custom-value")});
- std::string stream_frame_payload = QuicStrCat(headers, data, trailers);
+ std::string stream_frame_payload =
+ quiche::QuicheStrCat(headers, data, trailers);
QuicStreamFrame frame(stream_->id(), false, 0, stream_frame_payload);
stream_->OnStreamFrame(frame);
@@ -1820,7 +1827,8 @@
std::string trailers = HeadersFrame(trailers_block);
// Feed all three HTTP/3 frames in a single stream frame.
- std::string stream_frame_payload = QuicStrCat(headers, data, trailers);
+ std::string stream_frame_payload =
+ quiche::QuicheStrCat(headers, data, trailers);
QuicStreamFrame frame(stream_->id(), false, 0, stream_frame_payload);
stream_->OnStreamFrame(frame);
@@ -1838,7 +1846,7 @@
vec.iov_base = buffer;
vec.iov_len = QUIC_ARRAYSIZE(buffer);
size_t bytes_read = stream_->Readv(&vec, 1);
- EXPECT_EQ(kDataFramePayload, QuicStringPiece(buffer, bytes_read));
+ EXPECT_EQ(kDataFramePayload, quiche::QuicheStringPiece(buffer, bytes_read));
EXPECT_FALSE(stream_->HasBytesToRead());
}
@@ -1858,10 +1866,10 @@
// Random bad headers.
std::string headers =
- HeadersFrame(QuicTextUtils::HexDecode("00002a94e7036261"));
+ HeadersFrame(quiche::QuicheTextUtils::HexDecode("00002a94e7036261"));
std::string data = DataFrame(kDataFramePayload);
- std::string stream_frame_payload = QuicStrCat(headers, data);
+ std::string stream_frame_payload = quiche::QuicheStrCat(headers, data);
QuicStreamFrame frame(stream_->id(), false, 0, stream_frame_payload);
EXPECT_CALL(
@@ -1924,7 +1932,8 @@
// Invalid headers: Required Insert Count is zero, but the header block
// contains a dynamic table reference.
- std::string headers = HeadersFrame(QuicTextUtils::HexDecode("000080"));
+ std::string headers =
+ HeadersFrame(quiche::QuicheTextUtils::HexDecode("000080"));
QuicStreamFrame frame(stream_->id(), false, 0, headers);
stream_->OnStreamFrame(frame);
}
@@ -1948,7 +1957,8 @@
session_->qpack_decoder()->OnInsertWithoutNameReference("foo", "bar");
// HEADERS frame referencing first dynamic table entry.
- std::string headers = HeadersFrame(QuicTextUtils::HexDecode("020080"));
+ std::string headers =
+ HeadersFrame(quiche::QuicheTextUtils::HexDecode("020080"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
// Headers can be decoded immediately.
@@ -1970,7 +1980,8 @@
session_->qpack_decoder()->OnInsertWithoutNameReference("trailing", "foobar");
// Trailing HEADERS frame referencing second dynamic table entry.
- std::string trailers = HeadersFrame(QuicTextUtils::HexDecode("030080"));
+ std::string trailers =
+ HeadersFrame(quiche::QuicheTextUtils::HexDecode("030080"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), true, /* offset = */
headers.length() + data.length(),
trailers));
@@ -1994,7 +2005,8 @@
session_->qpack_decoder()->OnSetDynamicTableCapacity(1024);
// HEADERS frame referencing first dynamic table entry.
- std::string headers = HeadersFrame(QuicTextUtils::HexDecode("020080"));
+ std::string headers =
+ HeadersFrame(quiche::QuicheTextUtils::HexDecode("020080"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
// Decoding is blocked because dynamic table entry has not been received yet.
@@ -2021,7 +2033,8 @@
EXPECT_EQ(kDataFramePayload, stream_->data());
// Trailing HEADERS frame referencing second dynamic table entry.
- std::string trailers = HeadersFrame(QuicTextUtils::HexDecode("030080"));
+ std::string trailers =
+ HeadersFrame(quiche::QuicheTextUtils::HexDecode("030080"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), true, /* offset = */
headers.length() + data.length(),
trailers));
@@ -2051,7 +2064,8 @@
// HEADERS frame only referencing entry with absolute index 0 but with
// Required Insert Count = 2, which is incorrect.
- std::string headers = HeadersFrame(QuicTextUtils::HexDecode("030081"));
+ std::string headers =
+ HeadersFrame(quiche::QuicheTextUtils::HexDecode("030081"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
// Even though entire header block is received and every referenced entry is
@@ -2083,7 +2097,8 @@
session_->qpack_decoder()->OnSetDynamicTableCapacity(1024);
// Relative index 2 is invalid because it is larger than or equal to the Base.
- std::string headers = HeadersFrame(QuicTextUtils::HexDecode("020082"));
+ std::string headers =
+ HeadersFrame(quiche::QuicheTextUtils::HexDecode("020082"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
// Decoding is blocked.
@@ -2111,7 +2126,8 @@
session_->qpack_decoder()->OnSetDynamicTableCapacity(1024);
// HEADERS frame referencing first dynamic table entry.
- std::string headers = HeadersFrame(QuicTextUtils::HexDecode("020080"));
+ std::string headers =
+ HeadersFrame(quiche::QuicheTextUtils::HexDecode("020080"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
// Decoding is blocked because dynamic table entry has not been received yet.
@@ -2139,7 +2155,8 @@
// Trailing HEADERS frame only referencing entry with absolute index 0 but
// with Required Insert Count = 2, which is incorrect.
- std::string trailers = HeadersFrame(QuicTextUtils::HexDecode("030081"));
+ std::string trailers =
+ HeadersFrame(quiche::QuicheTextUtils::HexDecode("030081"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), true, /* offset = */
headers.length() + data.length(),
trailers));
@@ -2168,7 +2185,7 @@
// Create QuicStreamFrame with |payload|
// and pass it to stream_->OnStreamFrame().
- void OnStreamFrame(QuicStringPiece payload) {
+ void OnStreamFrame(quiche::QuicheStringPiece payload) {
QuicStreamFrame frame(stream_->id(), /* fin = */ false, offset_, payload);
stream_->OnStreamFrame(frame);
offset_ += payload.size();
@@ -2221,11 +2238,12 @@
// All HEADERS frame bytes are consumed even if the frame is not received
// completely.
- OnStreamFrame(QuicStringPiece(headers).substr(0, headers.size() - 1));
+ OnStreamFrame(
+ quiche::QuicheStringPiece(headers).substr(0, headers.size() - 1));
EXPECT_EQ(headers.size() - 1, NewlyConsumedBytes());
// The rest of the HEADERS frame is also consumed immediately.
- OnStreamFrame(QuicStringPiece(headers).substr(headers.size() - 1));
+ OnStreamFrame(quiche::QuicheStringPiece(headers).substr(headers.size() - 1));
EXPECT_EQ(1u, NewlyConsumedBytes());
// Verify headers.
@@ -2233,7 +2251,7 @@
stream_->ConsumeHeaderList();
// DATA frame.
- QuicStringPiece data_payload(kDataFramePayload);
+ quiche::QuicheStringPiece data_payload(kDataFramePayload);
std::string data_frame = DataFrame(data_payload);
QuicByteCount data_frame_header_length =
data_frame.size() - data_payload.size();
@@ -2252,7 +2270,8 @@
HeadersFrame({std::make_pair("custom-key", "custom-value")});
// No bytes are consumed, because last byte of DATA payload is still buffered.
- OnStreamFrame(QuicStringPiece(trailers).substr(0, trailers.size() - 1));
+ OnStreamFrame(
+ quiche::QuicheStringPiece(trailers).substr(0, trailers.size() - 1));
EXPECT_EQ(0u, NewlyConsumedBytes());
// Reading last byte of DATA payload triggers consumption of all data received
@@ -2261,7 +2280,8 @@
EXPECT_EQ(1 + trailers.size() - 1, NewlyConsumedBytes());
// Last byte of trailers is immediately consumed.
- OnStreamFrame(QuicStringPiece(trailers).substr(trailers.size() - 1));
+ OnStreamFrame(
+ quiche::QuicheStringPiece(trailers).substr(trailers.size() - 1));
EXPECT_EQ(1u, NewlyConsumedBytes());
// Verify trailers.
@@ -2285,11 +2305,12 @@
// All HEADERS frame bytes are consumed even if the frame is not received
// completely.
- OnStreamFrame(QuicStringPiece(headers).substr(0, headers.size() - 1));
+ OnStreamFrame(
+ quiche::QuicheStringPiece(headers).substr(0, headers.size() - 1));
EXPECT_EQ(headers.size() - 1, NewlyConsumedBytes());
// The rest of the HEADERS frame is also consumed immediately.
- OnStreamFrame(QuicStringPiece(headers).substr(headers.size() - 1));
+ OnStreamFrame(quiche::QuicheStringPiece(headers).substr(headers.size() - 1));
EXPECT_EQ(1u, NewlyConsumedBytes());
// Verify headers.
@@ -2303,7 +2324,7 @@
EXPECT_EQ(unknown_frame2.size(), NewlyConsumedBytes());
// DATA frame.
- QuicStringPiece data_payload(kDataFramePayload);
+ quiche::QuicheStringPiece data_payload(kDataFramePayload);
std::string data_frame = DataFrame(data_payload);
QuicByteCount data_frame_header_length =
data_frame.size() - data_payload.size();
@@ -2328,7 +2349,8 @@
HeadersFrame({std::make_pair("custom-key", "custom-value")});
// No bytes are consumed, because last byte of DATA payload is still buffered.
- OnStreamFrame(QuicStringPiece(trailers).substr(0, trailers.size() - 1));
+ OnStreamFrame(
+ quiche::QuicheStringPiece(trailers).substr(0, trailers.size() - 1));
EXPECT_EQ(0u, NewlyConsumedBytes());
// Reading last byte of DATA payload triggers consumption of all data received
@@ -2338,7 +2360,8 @@
NewlyConsumedBytes());
// Last byte of trailers is immediately consumed.
- OnStreamFrame(QuicStringPiece(trailers).substr(trailers.size() - 1));
+ OnStreamFrame(
+ quiche::QuicheStringPiece(trailers).substr(trailers.size() - 1));
EXPECT_EQ(1u, NewlyConsumedBytes());
// Verify trailers.
@@ -2508,7 +2531,7 @@
Initialize(kShouldProcessData);
// SETTINGS frame with empty payload.
- std::string settings = QuicTextUtils::HexDecode("0400");
+ std::string settings = quiche::QuicheTextUtils::HexDecode("0400");
// HEADERS frame.
// Since it arrives after a SETTINGS frame, it should never be read.
@@ -2516,7 +2539,7 @@
// Combine the two frames to make sure they are processed in a single
// QuicSpdyStream::OnDataAvailable() call.
- std::string frames = QuicStrCat(settings, headers);
+ std::string frames = quiche::QuicheStrCat(settings, headers);
EXPECT_EQ(0u, stream_->sequencer()->NumBytesConsumed());
diff --git a/quic/core/http/spdy_server_push_utils.cc b/quic/core/http/spdy_server_push_utils.cc
index 02c963c..4ba3289 100644
--- a/quic/core/http/spdy_server_push_utils.cc
+++ b/quic/core/http/spdy_server_push_utils.cc
@@ -5,6 +5,7 @@
#include "net/third_party/quiche/src/quic/core/http/spdy_server_push_utils.h"
#include "url/gurl.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
using spdy::SpdyHeaderBlock;
@@ -39,7 +40,7 @@
if (it == headers.end() || it->second.empty()) {
return std::string();
}
- QuicStringPiece scheme = it->second;
+ quiche::QuicheStringPiece scheme = it->second;
// RFC 7540, Section 8.2: The server MUST include a value in the
// ":authority" pseudo-header field for which the server is authoritative
@@ -48,7 +49,7 @@
if (it == headers.end() || it->second.empty()) {
return std::string();
}
- QuicStringPiece authority = it->second;
+ quiche::QuicheStringPiece authority = it->second;
// RFC 7540, Section 8.1.2.3 requires that the ":path" pseudo-header MUST
// NOT be empty for "http" or "https" URIs;
@@ -59,7 +60,7 @@
if (it == headers.end()) {
return std::string();
}
- QuicStringPiece path = it->second;
+ quiche::QuicheStringPiece path = it->second;
return GetPushPromiseUrl(scheme, authority, path);
}
@@ -79,9 +80,10 @@
}
// static
-std::string SpdyServerPushUtils::GetPushPromiseUrl(QuicStringPiece scheme,
- QuicStringPiece authority,
- QuicStringPiece path) {
+std::string SpdyServerPushUtils::GetPushPromiseUrl(
+ quiche::QuicheStringPiece scheme,
+ quiche::QuicheStringPiece authority,
+ quiche::QuicheStringPiece path) {
// RFC 7540, Section 8.1.2.3: The ":path" pseudo-header field includes the
// path and query parts of the target URI (the "path-absolute" production
// and optionally a '?' character followed by the "query" production (see
diff --git a/quic/core/http/spdy_server_push_utils.h b/quic/core/http/spdy_server_push_utils.h
index 3d11b65..16e1ac6 100644
--- a/quic/core/http/spdy_server_push_utils.h
+++ b/quic/core/http/spdy_server_push_utils.h
@@ -6,7 +6,7 @@
#define QUICHE_QUIC_CORE_HTTP_SPDY_SERVER_PUSH_UTILS_H_
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
namespace quic {
@@ -33,9 +33,9 @@
// Returns a canonical, valid URL for a PUSH_PROMISE with the specified
// ":scheme", ":authority", and ":path" header fields, or an empty
// string if the resulting URL is not valid or supported.
- static std::string GetPushPromiseUrl(QuicStringPiece scheme,
- QuicStringPiece authority,
- QuicStringPiece path);
+ static std::string GetPushPromiseUrl(quiche::QuicheStringPiece scheme,
+ quiche::QuicheStringPiece authority,
+ quiche::QuicheStringPiece path);
};
} // namespace quic
diff --git a/quic/core/http/spdy_server_push_utils_test.cc b/quic/core/http/spdy_server_push_utils_test.cc
index 0f6ec8a..aa35550 100644
--- a/quic/core/http/spdy_server_push_utils_test.cc
+++ b/quic/core/http/spdy_server_push_utils_test.cc
@@ -8,9 +8,7 @@
#include <string>
#include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
using spdy::SpdyHeaderBlock;
diff --git a/quic/core/http/spdy_utils.cc b/quic/core/http/spdy_utils.cc
index 56d3b19..98d22cb 100644
--- a/quic/core/http/spdy_utils.cc
+++ b/quic/core/http/spdy_utils.cc
@@ -12,9 +12,9 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.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"
#include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
using spdy::SpdyHeaderBlock;
@@ -29,12 +29,12 @@
return false;
} else {
// Check whether multiple values are consistent.
- QuicStringPiece content_length_header = it->second;
- std::vector<QuicStringPiece> values =
- QuicTextUtils::Split(content_length_header, '\0');
- for (const QuicStringPiece& value : values) {
+ quiche::QuicheStringPiece content_length_header = it->second;
+ std::vector<quiche::QuicheStringPiece> values =
+ quiche::QuicheTextUtils::Split(content_length_header, '\0');
+ for (const quiche::QuicheStringPiece& value : values) {
uint64_t new_value;
- if (!QuicTextUtils::StringToUint64(value, &new_value)) {
+ if (!quiche::QuicheTextUtils::StringToUint64(value, &new_value)) {
QUIC_DLOG(ERROR)
<< "Content length was either unparseable or negative.";
return false;
@@ -65,7 +65,7 @@
return false;
}
- if (QuicTextUtils::ContainsUpperCase(name)) {
+ if (quiche::QuicheTextUtils::ContainsUpperCase(name)) {
QUIC_DLOG(ERROR) << "Malformed header: Header name " << name
<< " contains upper-case characters.";
return false;
@@ -95,7 +95,7 @@
// response body bytes expected.
if (expect_final_byte_offset && !found_final_byte_offset &&
name == kFinalOffsetHeaderKey &&
- QuicTextUtils::StringToSizeT(p.second, final_byte_offset)) {
+ quiche::QuicheTextUtils::StringToSizeT(p.second, final_byte_offset)) {
found_final_byte_offset = true;
continue;
}
@@ -107,7 +107,7 @@
return false;
}
- if (QuicTextUtils::ContainsUpperCase(name)) {
+ if (quiche::QuicheTextUtils::ContainsUpperCase(name)) {
QUIC_DLOG(ERROR) << "Malformed header: Header name " << name
<< " contains upper-case characters.";
return false;
@@ -162,7 +162,7 @@
RETURN_STRING_LITERAL(SETTINGS_MAX_HEADER_LIST_SIZE);
RETURN_STRING_LITERAL(SETTINGS_QPACK_BLOCKED_STREAMS);
}
- return QuicStrCat("UNSUPPORTED_SETTINGS_TYPE(", identifier, ")");
+ return quiche::QuicheStrCat("UNSUPPORTED_SETTINGS_TYPE(", identifier, ")");
}
#undef RETURN_STRING_LITERAL // undef for jumbo builds
diff --git a/quic/core/http/spdy_utils_test.cc b/quic/core/http/spdy_utils_test.cc
index 2ebf0cf..898d5f7 100644
--- a/quic/core/http/spdy_utils_test.cc
+++ b/quic/core/http/spdy_utils_test.cc
@@ -7,9 +7,9 @@
#include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.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"
using spdy::SpdyHeaderBlock;
using testing::Pair;
@@ -66,13 +66,14 @@
SpdyHeaderBlock block;
ASSERT_TRUE(
SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
- EXPECT_THAT(block,
- UnorderedElementsAre(
- Pair("cookie", " part 1; part 2 ; part3; fin!"),
- Pair("passed-through", QuicStringPiece("foo\0baz", 7)),
- Pair("joined", QuicStringPiece("value 1\0value 2", 15)),
- Pair("empty", ""),
- Pair("empty-joined", QuicStringPiece("\0foo\0\0", 6))));
+ EXPECT_THAT(
+ block,
+ UnorderedElementsAre(
+ Pair("cookie", " part 1; part 2 ; part3; fin!"),
+ Pair("passed-through", quiche::QuicheStringPiece("foo\0baz", 7)),
+ Pair("joined", quiche::QuicheStringPiece("value 1\0value 2", 15)),
+ Pair("empty", ""),
+ Pair("empty-joined", quiche::QuicheStringPiece("\0foo\0\0", 6))));
EXPECT_EQ(-1, content_length);
}
@@ -103,10 +104,11 @@
SpdyHeaderBlock block;
ASSERT_TRUE(
SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
- EXPECT_THAT(block, UnorderedElementsAre(
- Pair("foo", "foovalue"), Pair("bar", "barvalue"),
- Pair("content-length", QuicStringPiece("9\09", 3)),
- Pair("baz", "")));
+ EXPECT_THAT(block,
+ UnorderedElementsAre(
+ Pair("foo", "foovalue"), Pair("bar", "barvalue"),
+ Pair("content-length", quiche::QuicheStringPiece("9\09", 3)),
+ Pair("baz", "")));
EXPECT_EQ(9, content_length);
}
@@ -133,7 +135,8 @@
SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
EXPECT_THAT(block, UnorderedElementsAre(
Pair("foo", "foovalue"), Pair("bar", "barvalue"),
- Pair("content-length", QuicStringPiece("9000000000")),
+ Pair("content-length",
+ quiche::QuicheStringPiece("9000000000")),
Pair("baz", "")));
EXPECT_EQ(9000000000, content_length);
}
@@ -148,10 +151,11 @@
SpdyHeaderBlock block;
ASSERT_TRUE(
SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
- EXPECT_THAT(block, UnorderedElementsAre(
- Pair("foo", QuicStringPiece("foovalue\0boo", 12)),
- Pair("bar", "barvalue"),
- Pair("baz", QuicStringPiece("\0buzz", 5))));
+ EXPECT_THAT(block,
+ UnorderedElementsAre(
+ Pair("foo", quiche::QuicheStringPiece("foovalue\0boo", 12)),
+ Pair("bar", "barvalue"),
+ Pair("baz", quiche::QuicheStringPiece("\0buzz", 5))));
EXPECT_EQ(-1, content_length);
}
@@ -163,9 +167,9 @@
SpdyHeaderBlock block;
ASSERT_TRUE(
SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
- EXPECT_THAT(
- block, UnorderedElementsAre(Pair(
- "set-cookie", QuicStringPiece("value1\0value2\0value3", 20))));
+ EXPECT_THAT(block, UnorderedElementsAre(Pair(
+ "set-cookie", quiche::QuicheStringPiece(
+ "value1\0value2\0value3", 20))));
EXPECT_EQ(-1, content_length);
}
@@ -307,7 +311,7 @@
block,
UnorderedElementsAre(
Pair("key",
- QuicStringPiece(
+ quiche::QuicheStringPiece(
"value0\0value1\0\0\0value2\0\0non_contiguous_duplicate",
48)),
Pair("other_key", "value")));
