Use quiche string libraries in third_party/quic/tools
gfe-relnote: n/a, no functional change
PiperOrigin-RevId: 285002617
Change-Id: If94b091b6b1c92ae3a497d13915dbe74d4e5703a
diff --git a/quic/tools/fake_proof_verifier.h b/quic/tools/fake_proof_verifier.h
index ffeb6e9..a605e07 100644
--- a/quic/tools/fake_proof_verifier.h
+++ b/quic/tools/fake_proof_verifier.h
@@ -6,6 +6,7 @@
#define QUICHE_QUIC_TOOLS_FAKE_PROOF_VERIFIER_H_
#include "net/third_party/quiche/src/quic/core/crypto/proof_verifier.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -18,7 +19,7 @@
const uint16_t /*port*/,
const std::string& /*server_config*/,
QuicTransportVersion /*quic_version*/,
- QuicStringPiece /*chlo_hash*/,
+ quiche::QuicheStringPiece /*chlo_hash*/,
const std::vector<std::string>& /*certs*/,
const std::string& /*cert_sct*/,
const std::string& /*signature*/,
diff --git a/quic/tools/quic_backend_response.h b/quic/tools/quic_backend_response.h
index f0b7b89..6537987 100644
--- a/quic/tools/quic_backend_response.h
+++ b/quic/tools/quic_backend_response.h
@@ -6,6 +6,7 @@
#define QUICHE_QUIC_TOOLS_QUIC_BACKEND_RESPONSE_H_
#include "net/third_party/quiche/src/quic/tools/quic_url.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 {
@@ -55,7 +56,9 @@
SpecialResponseType response_type() const { return response_type_; }
const spdy::SpdyHeaderBlock& headers() const { return headers_; }
const spdy::SpdyHeaderBlock& trailers() const { return trailers_; }
- const QuicStringPiece body() const { return QuicStringPiece(body_); }
+ const quiche::QuicheStringPiece body() const {
+ return quiche::QuicheStringPiece(body_);
+ }
void set_response_type(SpecialResponseType response_type) {
response_type_ = response_type;
@@ -67,7 +70,7 @@
void set_trailers(spdy::SpdyHeaderBlock trailers) {
trailers_ = std::move(trailers);
}
- void set_body(QuicStringPiece body) {
+ void set_body(quiche::QuicheStringPiece body) {
body_.assign(body.data(), body.size());
}
uint16_t stop_sending_code() const { return stop_sending_code_; }
diff --git a/quic/tools/quic_client_base.cc b/quic/tools/quic_client_base.cc
index b6c3375..b291463 100644
--- a/quic/tools/quic_client_base.cc
+++ b/quic/tools/quic_client_base.cc
@@ -10,7 +10,6 @@
#include "net/third_party/quiche/src/quic/core/quic_utils.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_text_utils.h"
namespace quic {
diff --git a/quic/tools/quic_client_base.h b/quic/tools/quic_client_base.h
index 8cb639b..3160b74 100644
--- a/quic/tools/quic_client_base.h
+++ b/quic/tools/quic_client_base.h
@@ -17,7 +17,7 @@
#include "net/third_party/quiche/src/quic/core/quic_config.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_macros.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.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 {
@@ -209,7 +209,7 @@
bool initialized() const { return initialized_; }
- void SetPreSharedKey(QuicStringPiece key) {
+ void SetPreSharedKey(quiche::QuicheStringPiece key) {
crypto_config_.set_pre_shared_key(key);
}
diff --git a/quic/tools/quic_client_interop_test_bin.cc b/quic/tools/quic_client_interop_test_bin.cc
index 8c9f6d1..bea0127 100644
--- a/quic/tools/quic_client_interop_test_bin.cc
+++ b/quic/tools/quic_client_interop_test_bin.cc
@@ -18,6 +18,7 @@
#include "net/third_party/quiche/src/quic/tools/fake_proof_verifier.h"
#include "net/third_party/quiche/src/quic/tools/quic_client.h"
#include "net/third_party/quiche/src/quic/tools/quic_url.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
host,
@@ -252,13 +253,14 @@
QuicEnableVersion(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99));
// Build the client, and try to connect.
- QuicSocketAddress addr = tools::LookupAddress(host, QuicStrCat(port));
+ QuicSocketAddress addr =
+ tools::LookupAddress(host, quiche::QuicheStrCat(port));
if (!addr.IsInitialized()) {
QUIC_LOG(ERROR) << "Failed to resolve " << host;
return std::set<Feature>();
}
QuicServerId server_id(host, port, false);
- std::string authority = QuicStrCat(host, ":", port);
+ std::string authority = quiche::QuicheStrCat(host, ":", port);
return AttemptRequest(addr, authority, server_id,
/*test_version_negotiation=*/true,
diff --git a/quic/tools/quic_client_test.cc b/quic/tools/quic_client_test.cc
index e460de4..b1923b6 100644
--- a/quic/tools/quic_client_test.cc
+++ b/quic/tools/quic_client_test.cc
@@ -12,12 +12,12 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_epoll.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_port_utils.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/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_client_peer.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 {
@@ -40,13 +40,13 @@
std::unique_ptr<DIR, int (*)(DIR*)> fd_directory(opendir(kPathToFds),
closedir);
while ((file = readdir(fd_directory.get())) != nullptr) {
- QuicStringPiece name(file->d_name);
+ quiche::QuicheStringPiece name(file->d_name);
if (name == "." || name == "..") {
continue;
}
- std::string fd_path = ReadLink(QuicStrCat(kPathToFds, "/", name));
- if (QuicTextUtils::StartsWith(fd_path, "socket:")) {
+ std::string fd_path = ReadLink(quiche::QuicheStrCat(kPathToFds, "/", name));
+ if (quiche::QuicheTextUtils::StartsWith(fd_path, "socket:")) {
socket_count++;
}
}
diff --git a/quic/tools/quic_epoll_client_factory.cc b/quic/tools/quic_epoll_client_factory.cc
index 113958f..1751f41 100644
--- a/quic/tools/quic_epoll_client_factory.cc
+++ b/quic/tools/quic_epoll_client_factory.cc
@@ -13,6 +13,7 @@
#include "net/third_party/quiche/src/quic/core/quic_server_id.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
#include "net/third_party/quiche/src/quic/tools/quic_client.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
namespace quic {
@@ -23,7 +24,7 @@
ParsedQuicVersionVector versions,
std::unique_ptr<ProofVerifier> verifier) {
QuicSocketAddress addr =
- tools::LookupAddress(host_for_lookup, QuicStrCat(port));
+ tools::LookupAddress(host_for_lookup, quiche::QuicheStrCat(port));
if (!addr.IsInitialized()) {
QUIC_LOG(ERROR) << "Unable to resolve address: " << host_for_lookup;
return nullptr;
diff --git a/quic/tools/quic_memory_cache_backend.cc b/quic/tools/quic_memory_cache_backend.cc
index 38d25e5..a769259 100644
--- a/quic/tools/quic_memory_cache_backend.cc
+++ b/quic/tools/quic_memory_cache_backend.cc
@@ -11,7 +11,8 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_file_utils.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_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::kV3LowestPriority;
using spdy::SpdyHeaderBlock;
@@ -39,7 +40,7 @@
if (file_contents_[pos - 1] == '\r') {
len -= 1;
}
- QuicStringPiece line(file_contents_.data() + start, len);
+ quiche::QuicheStringPiece line(file_contents_.data() + start, len);
start = pos + 1;
// Headers end with an empty line.
if (line.empty()) {
@@ -63,7 +64,8 @@
return;
}
spdy_headers_.AppendValueOrAddHeader(
- QuicTextUtils::ToLower(line.substr(0, pos)), line.substr(pos + 2));
+ quiche::QuicheTextUtils::ToLower(line.substr(0, pos)),
+ line.substr(pos + 2));
}
// The connection header is prohibited in HTTP/2.
@@ -81,26 +83,27 @@
// stuff as described in https://w3c.github.io/preload/.
it = spdy_headers_.find("x-push-url");
if (it != spdy_headers_.end()) {
- QuicStringPiece push_urls = it->second;
+ quiche::QuicheStringPiece push_urls = it->second;
size_t start = 0;
while (start < push_urls.length()) {
size_t pos = push_urls.find('\0', start);
if (pos == std::string::npos) {
- push_urls_.push_back(QuicStringPiece(push_urls.data() + start,
- push_urls.length() - start));
+ push_urls_.push_back(quiche::QuicheStringPiece(
+ push_urls.data() + start, push_urls.length() - start));
break;
}
- push_urls_.push_back(QuicStringPiece(push_urls.data() + start, pos));
+ push_urls_.push_back(
+ quiche::QuicheStringPiece(push_urls.data() + start, pos));
start += pos + 1;
}
}
- body_ = QuicStringPiece(file_contents_.data() + start,
- file_contents_.size() - start);
+ body_ = quiche::QuicheStringPiece(file_contents_.data() + start,
+ file_contents_.size() - start);
}
void QuicMemoryCacheBackend::ResourceFile::SetHostPathFromBase(
- QuicStringPiece base) {
+ quiche::QuicheStringPiece base) {
size_t path_start = base.find_first_of('/');
DCHECK_LT(0UL, path_start);
host_ = base.substr(0, path_start);
@@ -112,34 +115,35 @@
}
}
-QuicStringPiece QuicMemoryCacheBackend::ResourceFile::RemoveScheme(
- QuicStringPiece url) {
- if (QuicTextUtils::StartsWith(url, "https://")) {
+quiche::QuicheStringPiece QuicMemoryCacheBackend::ResourceFile::RemoveScheme(
+ quiche::QuicheStringPiece url) {
+ if (quiche::QuicheTextUtils::StartsWith(url, "https://")) {
url.remove_prefix(8);
- } else if (QuicTextUtils::StartsWith(url, "http://")) {
+ } else if (quiche::QuicheTextUtils::StartsWith(url, "http://")) {
url.remove_prefix(7);
}
return url;
}
void QuicMemoryCacheBackend::ResourceFile::HandleXOriginalUrl() {
- QuicStringPiece url(x_original_url_);
+ quiche::QuicheStringPiece url(x_original_url_);
// Remove the protocol so we can add it below.
url = RemoveScheme(url);
SetHostPathFromBase(url);
}
const QuicBackendResponse* QuicMemoryCacheBackend::GetResponse(
- QuicStringPiece host,
- QuicStringPiece path) const {
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path) const {
QuicWriterMutexLock lock(&response_mutex_);
auto it = responses_.find(GetKey(host, path));
if (it == responses_.end()) {
uint64_t ignored = 0;
if (generate_bytes_response_) {
- if (QuicTextUtils::StringToUint64(
- QuicStringPiece(path.data() + 1, path.size() - 1), &ignored)) {
+ if (quiche::QuicheTextUtils::StringToUint64(
+ quiche::QuicheStringPiece(path.data() + 1, path.size() - 1),
+ &ignored)) {
// The actual parsed length is ignored here and will be recomputed
// by the caller.
return generate_bytes_response_.get();
@@ -158,22 +162,23 @@
typedef QuicBackendResponse::ServerPushInfo ServerPushInfo;
typedef QuicBackendResponse::SpecialResponseType SpecialResponseType;
-void QuicMemoryCacheBackend::AddSimpleResponse(QuicStringPiece host,
- QuicStringPiece path,
+void QuicMemoryCacheBackend::AddSimpleResponse(quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
int response_code,
- QuicStringPiece body) {
+ quiche::QuicheStringPiece body) {
SpdyHeaderBlock response_headers;
- response_headers[":status"] = QuicTextUtils::Uint64ToString(response_code);
+ response_headers[":status"] =
+ quiche::QuicheTextUtils::Uint64ToString(response_code);
response_headers["content-length"] =
- QuicTextUtils::Uint64ToString(body.length());
+ quiche::QuicheTextUtils::Uint64ToString(body.length());
AddResponse(host, path, std::move(response_headers), body);
}
void QuicMemoryCacheBackend::AddSimpleResponseWithServerPushResources(
- QuicStringPiece host,
- QuicStringPiece path,
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
int response_code,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
std::list<ServerPushInfo> push_resources) {
AddSimpleResponse(host, path, response_code, body);
MaybeAddServerPushResources(host, path, push_resources);
@@ -184,48 +189,50 @@
default_response_.reset(response);
}
-void QuicMemoryCacheBackend::AddResponse(QuicStringPiece host,
- QuicStringPiece path,
- SpdyHeaderBlock response_headers,
- QuicStringPiece response_body) {
+void QuicMemoryCacheBackend::AddResponse(
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
+ SpdyHeaderBlock response_headers,
+ quiche::QuicheStringPiece response_body) {
AddResponseImpl(host, path, QuicBackendResponse::REGULAR_RESPONSE,
std::move(response_headers), response_body, SpdyHeaderBlock(),
0);
}
-void QuicMemoryCacheBackend::AddResponse(QuicStringPiece host,
- QuicStringPiece path,
- SpdyHeaderBlock response_headers,
- QuicStringPiece response_body,
- SpdyHeaderBlock response_trailers) {
+void QuicMemoryCacheBackend::AddResponse(
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
+ SpdyHeaderBlock response_headers,
+ quiche::QuicheStringPiece response_body,
+ SpdyHeaderBlock response_trailers) {
AddResponseImpl(host, path, QuicBackendResponse::REGULAR_RESPONSE,
std::move(response_headers), response_body,
std::move(response_trailers), 0);
}
void QuicMemoryCacheBackend::AddSpecialResponse(
- QuicStringPiece host,
- QuicStringPiece path,
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
SpecialResponseType response_type) {
AddResponseImpl(host, path, response_type, SpdyHeaderBlock(), "",
SpdyHeaderBlock(), 0);
}
void QuicMemoryCacheBackend::AddSpecialResponse(
- QuicStringPiece host,
- QuicStringPiece path,
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
spdy::SpdyHeaderBlock response_headers,
- QuicStringPiece response_body,
+ quiche::QuicheStringPiece response_body,
SpecialResponseType response_type) {
AddResponseImpl(host, path, response_type, std::move(response_headers),
response_body, SpdyHeaderBlock(), 0);
}
void QuicMemoryCacheBackend::AddStopSendingResponse(
- QuicStringPiece host,
- QuicStringPiece path,
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
spdy::SpdyHeaderBlock response_headers,
- QuicStringPiece response_body,
+ quiche::QuicheStringPiece response_body,
uint16_t stop_sending_code) {
AddResponseImpl(host, path, SpecialResponseType::STOP_SENDING,
std::move(response_headers), response_body, SpdyHeaderBlock(),
@@ -249,7 +256,7 @@
std::unique_ptr<ResourceFile> resource_file(new ResourceFile(filename));
// Tease apart filename into host and path.
- QuicStringPiece base(resource_file->file_name());
+ quiche::QuicheStringPiece base(resource_file->file_name());
base.remove_prefix(cache_directory.length());
if (base[0] == '/') {
base.remove_prefix(1);
@@ -346,13 +353,14 @@
}
}
-void QuicMemoryCacheBackend::AddResponseImpl(QuicStringPiece host,
- QuicStringPiece path,
- SpecialResponseType response_type,
- SpdyHeaderBlock response_headers,
- QuicStringPiece response_body,
- SpdyHeaderBlock response_trailers,
- uint16_t stop_sending_code) {
+void QuicMemoryCacheBackend::AddResponseImpl(
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
+ SpecialResponseType response_type,
+ SpdyHeaderBlock response_headers,
+ quiche::QuicheStringPiece response_body,
+ SpdyHeaderBlock response_trailers,
+ uint16_t stop_sending_code) {
QuicWriterMutexLock lock(&response_mutex_);
DCHECK(!host.empty()) << "Host must be populated, e.g. \"www.google.com\"";
@@ -371,8 +379,9 @@
responses_[key] = std::move(new_response);
}
-std::string QuicMemoryCacheBackend::GetKey(QuicStringPiece host,
- QuicStringPiece path) const {
+std::string QuicMemoryCacheBackend::GetKey(
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path) const {
std::string host_string = std::string(host);
size_t port = host_string.find(':');
if (port != std::string::npos)
@@ -381,8 +390,8 @@
}
void QuicMemoryCacheBackend::MaybeAddServerPushResources(
- QuicStringPiece request_host,
- QuicStringPiece request_path,
+ quiche::QuicheStringPiece request_host,
+ quiche::QuicheStringPiece request_path,
std::list<ServerPushInfo> push_resources) {
std::string request_url = GetKey(request_host, request_path);
@@ -412,7 +421,7 @@
}
if (!found_existing_response) {
// Add a server push response to responses map, if it is not in the map.
- QuicStringPiece body = push_resource.body;
+ quiche::QuicheStringPiece body = push_resource.body;
QUIC_DVLOG(1) << "Add response for push resource: host " << host
<< " path " << path;
AddResponse(host, path, push_resource.headers.Clone(), body);
diff --git a/quic/tools/quic_memory_cache_backend.h b/quic/tools/quic_memory_cache_backend.h
index f88d458..48a5c59 100644
--- a/quic/tools/quic_memory_cache_backend.h
+++ b/quic/tools/quic_memory_cache_backend.h
@@ -13,10 +13,10 @@
#include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_mutex.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
#include "net/third_party/quiche/src/quic/tools/quic_backend_response.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_server_backend.h"
#include "net/third_party/quiche/src/quic/tools/quic_url.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 {
@@ -40,34 +40,36 @@
void Read();
// |base| is |file_name_| with |cache_directory| prefix stripped.
- void SetHostPathFromBase(QuicStringPiece base);
+ void SetHostPathFromBase(quiche::QuicheStringPiece base);
const std::string& file_name() { return file_name_; }
- QuicStringPiece host() { return host_; }
+ quiche::QuicheStringPiece host() { return host_; }
- QuicStringPiece path() { return path_; }
+ quiche::QuicheStringPiece path() { return path_; }
const spdy::SpdyHeaderBlock& spdy_headers() { return spdy_headers_; }
- QuicStringPiece body() { return body_; }
+ quiche::QuicheStringPiece body() { return body_; }
- const std::vector<QuicStringPiece>& push_urls() { return push_urls_; }
+ const std::vector<quiche::QuicheStringPiece>& push_urls() {
+ return push_urls_;
+ }
protected:
void HandleXOriginalUrl();
- QuicStringPiece RemoveScheme(QuicStringPiece url);
+ quiche::QuicheStringPiece RemoveScheme(quiche::QuicheStringPiece url);
std::string file_name_;
std::string file_contents_;
- QuicStringPiece body_;
+ quiche::QuicheStringPiece body_;
spdy::SpdyHeaderBlock spdy_headers_;
- QuicStringPiece x_original_url_;
- std::vector<QuicStringPiece> push_urls_;
+ quiche::QuicheStringPiece x_original_url_;
+ std::vector<quiche::QuicheStringPiece> push_urls_;
private:
- QuicStringPiece host_;
- QuicStringPiece path_;
+ quiche::QuicheStringPiece host_;
+ quiche::QuicheStringPiece path_;
};
QuicMemoryCacheBackend();
@@ -77,57 +79,57 @@
// Retrieve a response from this cache for a given host and path..
// If no appropriate response exists, nullptr is returned.
- const QuicBackendResponse* GetResponse(QuicStringPiece host,
- QuicStringPiece path) const;
+ const QuicBackendResponse* GetResponse(quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path) const;
// Adds a simple response to the cache. The response headers will
// only contain the "content-length" header with the length of |body|.
- void AddSimpleResponse(QuicStringPiece host,
- QuicStringPiece path,
+ void AddSimpleResponse(quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
int response_code,
- QuicStringPiece body);
+ quiche::QuicheStringPiece body);
// Add a simple response to the cache as AddSimpleResponse() does, and add
// some server push resources(resource path, corresponding response status and
// path) associated with it.
// Push resource implicitly come from the same host.
void AddSimpleResponseWithServerPushResources(
- QuicStringPiece host,
- QuicStringPiece path,
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
int response_code,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
std::list<QuicBackendResponse::ServerPushInfo> push_resources);
// Add a response to the cache.
- void AddResponse(QuicStringPiece host,
- QuicStringPiece path,
+ void AddResponse(quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
spdy::SpdyHeaderBlock response_headers,
- QuicStringPiece response_body);
+ quiche::QuicheStringPiece response_body);
// Add a response, with trailers, to the cache.
- void AddResponse(QuicStringPiece host,
- QuicStringPiece path,
+ void AddResponse(quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
spdy::SpdyHeaderBlock response_headers,
- QuicStringPiece response_body,
+ quiche::QuicheStringPiece response_body,
spdy::SpdyHeaderBlock response_trailers);
// Simulate a special behavior at a particular path.
void AddSpecialResponse(
- QuicStringPiece host,
- QuicStringPiece path,
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
QuicBackendResponse::SpecialResponseType response_type);
void AddSpecialResponse(
- QuicStringPiece host,
- QuicStringPiece path,
+ quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
spdy::SpdyHeaderBlock response_headers,
- QuicStringPiece response_body,
+ quiche::QuicheStringPiece response_body,
QuicBackendResponse::SpecialResponseType response_type);
- void AddStopSendingResponse(QuicStringPiece host,
- QuicStringPiece path,
+ void AddStopSendingResponse(quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
spdy::SpdyHeaderBlock response_headers,
- QuicStringPiece response_body,
+ quiche::QuicheStringPiece response_body,
uint16_t stop_sending_code);
// Sets a default response in case of cache misses. Takes ownership of
@@ -154,21 +156,22 @@
QuicSimpleServerBackend::RequestHandler* quic_server_stream) override;
private:
- void AddResponseImpl(QuicStringPiece host,
- QuicStringPiece path,
+ void AddResponseImpl(quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path,
QuicBackendResponse::SpecialResponseType response_type,
spdy::SpdyHeaderBlock response_headers,
- QuicStringPiece response_body,
+ quiche::QuicheStringPiece response_body,
spdy::SpdyHeaderBlock response_trailers,
uint16_t stop_sending_code);
- std::string GetKey(QuicStringPiece host, QuicStringPiece path) const;
+ std::string GetKey(quiche::QuicheStringPiece host,
+ quiche::QuicheStringPiece path) const;
// Add some server push urls with given responses for specified
// request if these push resources are not associated with this request yet.
void MaybeAddServerPushResources(
- QuicStringPiece request_host,
- QuicStringPiece request_path,
+ quiche::QuicheStringPiece request_host,
+ quiche::QuicheStringPiece request_path,
std::list<QuicBackendResponse::ServerPushInfo> push_resources);
// Check if push resource(push_host/push_path) associated with given request
diff --git a/quic/tools/quic_memory_cache_backend_test.cc b/quic/tools/quic_memory_cache_backend_test.cc
index 01ac334..c028e41 100644
--- a/quic/tools/quic_memory_cache_backend_test.cc
+++ b/quic/tools/quic_memory_cache_backend_test.cc
@@ -5,10 +5,10 @@
#include "net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.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_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/third_party/quiche/src/quic/tools/quic_backend_response.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
namespace test {
@@ -61,7 +61,7 @@
spdy::SpdyHeaderBlock response_headers;
response_headers[":status"] = "200";
response_headers["content-length"] =
- QuicTextUtils::Uint64ToString(kResponseBody.size());
+ quiche::QuicheTextUtils::Uint64ToString(kResponseBody.size());
spdy::SpdyHeaderBlock response_trailers;
response_trailers["key-1"] = "value-1";
@@ -156,15 +156,16 @@
std::list<ServerPushInfo> push_resources;
std::string scheme = "http";
for (int i = 0; i < NumResources; ++i) {
- std::string path = "/server_push_src" + QuicTextUtils::Uint64ToString(i);
+ std::string path =
+ "/server_push_src" + quiche::QuicheTextUtils::Uint64ToString(i);
std::string url = scheme + "://" + request_host + path;
QuicUrl resource_url(url);
std::string body =
- QuicStrCat("This is server push response body for ", path);
+ quiche::QuicheStrCat("This is server push response body for ", path);
spdy::SpdyHeaderBlock response_headers;
response_headers[":status"] = "200";
response_headers["content-length"] =
- QuicTextUtils::Uint64ToString(body.size());
+ quiche::QuicheTextUtils::Uint64ToString(body.size());
push_resources.push_back(
ServerPushInfo(resource_url, response_headers.Clone(), i, body));
}
@@ -195,14 +196,15 @@
"404"};
std::list<ServerPushInfo> push_resources;
for (int i = 0; i < NumResources; ++i) {
- std::string path = "/server_push_src" + QuicTextUtils::Uint64ToString(i);
+ std::string path =
+ "/server_push_src" + quiche::QuicheTextUtils::Uint64ToString(i);
std::string url = scheme + "://" + request_host + path;
QuicUrl resource_url(url);
std::string body = "This is server push response body for " + path;
spdy::SpdyHeaderBlock response_headers;
response_headers[":status"] = push_response_status[i];
response_headers["content-length"] =
- QuicTextUtils::Uint64ToString(body.size());
+ quiche::QuicheTextUtils::Uint64ToString(body.size());
push_resources.push_back(
ServerPushInfo(resource_url, response_headers.Clone(), i, body));
}
diff --git a/quic/tools/quic_packet_printer_bin.cc b/quic/tools/quic_packet_printer_bin.cc
index 7738ea7..20f4cf8 100644
--- a/quic/tools/quic_packet_printer_bin.cc
+++ b/quic/tools/quic_packet_printer_bin.cc
@@ -31,7 +31,8 @@
#include "net/third_party/quiche/src/quic/core/quic_framer.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
quic_version,
@@ -64,7 +65,7 @@
}
void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
QuicConnectionId /*new_connection_id*/,
- QuicStringPiece /*retry_token*/) override {
+ quiche::QuicheStringPiece /*retry_token*/) override {
std::cerr << "OnRetryPacket\n";
}
bool OnUnauthenticatedPublicHeader(
@@ -96,14 +97,16 @@
bool OnStreamFrame(const QuicStreamFrame& frame) override {
std::cerr << "OnStreamFrame: " << frame;
std::cerr << " data: { "
- << QuicTextUtils::HexEncode(frame.data_buffer, frame.data_length)
+ << quiche::QuicheTextUtils::HexEncode(frame.data_buffer,
+ frame.data_length)
<< " }\n";
return true;
}
bool OnCryptoFrame(const QuicCryptoFrame& frame) override {
std::cerr << "OnCryptoFrame: " << frame;
std::cerr << " data: { "
- << QuicTextUtils::HexEncode(frame.data_buffer, frame.data_length)
+ << quiche::QuicheTextUtils::HexEncode(frame.data_buffer,
+ frame.data_length)
<< " }\n";
return true;
}
@@ -235,7 +238,7 @@
quic::QuicPrintCommandLineFlagHelp(usage);
return 1;
}
- std::string hex = quic::QuicTextUtils::HexDecode(args[1]);
+ std::string hex = quiche::QuicheTextUtils::HexDecode(args[1]);
quic::ParsedQuicVersionVector versions = quic::AllSupportedVersions();
// Fake a time since we're not actually generating acks.
quic::QuicTime start(quic::QuicTime::Zero());
diff --git a/quic/tools/quic_reject_reason_decoder_bin.cc b/quic/tools/quic_reject_reason_decoder_bin.cc
index de66774..f7e3b75 100644
--- a/quic/tools/quic_reject_reason_decoder_bin.cc
+++ b/quic/tools/quic_reject_reason_decoder_bin.cc
@@ -10,7 +10,7 @@
#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
using quic::CryptoUtils;
using quic::HandshakeFailureReason;
@@ -27,7 +27,7 @@
}
uint32_t packed_error = 0;
- if (!quic::QuicTextUtils::StringToUint32(args[0], &packed_error)) {
+ if (!quiche::QuicheTextUtils::StringToUint32(args[0], &packed_error)) {
std::cerr << "Unable to parse: " << args[0] << "\n";
return 2;
}
diff --git a/quic/tools/quic_server.h b/quic/tools/quic_server.h
index 0b11be3..d2d9782 100644
--- a/quic/tools/quic_server.h
+++ b/quic/tools/quic_server.h
@@ -23,6 +23,7 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_server_backend.h"
#include "net/third_party/quiche/src/quic/tools/quic_spdy_server_base.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -79,7 +80,7 @@
crypto_config_.set_chlo_multiplier(multiplier);
}
- void SetPreSharedKey(QuicStringPiece key) {
+ void SetPreSharedKey(quiche::QuicheStringPiece key) {
crypto_config_.set_pre_shared_key(key);
}
diff --git a/quic/tools/quic_simple_dispatcher.cc b/quic/tools/quic_simple_dispatcher.cc
index 0f4d447..f5f5a6c 100644
--- a/quic/tools/quic_simple_dispatcher.cc
+++ b/quic/tools/quic_simple_dispatcher.cc
@@ -5,6 +5,7 @@
#include "net/third_party/quiche/src/quic/tools/quic_simple_dispatcher.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_server_session.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -50,7 +51,7 @@
QuicServerSessionBase* QuicSimpleDispatcher::CreateQuicSession(
QuicConnectionId connection_id,
const QuicSocketAddress& client_address,
- QuicStringPiece /*alpn*/,
+ quiche::QuicheStringPiece /*alpn*/,
const ParsedQuicVersion& version) {
// The QuicServerSessionBase takes ownership of |connection| below.
QuicConnection* connection = new QuicConnection(
diff --git a/quic/tools/quic_simple_dispatcher.h b/quic/tools/quic_simple_dispatcher.h
index 8a6cf85..4d04400 100644
--- a/quic/tools/quic_simple_dispatcher.h
+++ b/quic/tools/quic_simple_dispatcher.h
@@ -8,6 +8,7 @@
#include "net/third_party/quiche/src/quic/core/http/quic_server_session_base.h"
#include "net/third_party/quiche/src/quic/core/quic_dispatcher.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_server_backend.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -33,7 +34,7 @@
QuicServerSessionBase* CreateQuicSession(
QuicConnectionId connection_id,
const QuicSocketAddress& client_address,
- QuicStringPiece alpn,
+ quiche::QuicheStringPiece alpn,
const ParsedQuicVersion& version) override;
QuicSimpleServerBackend* server_backend() {
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index 0af12e2..96cb3ac 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -20,9 +20,7 @@
#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_socket_address.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/crypto_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/mock_quic_session_visitor.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
@@ -36,6 +34,8 @@
#include "net/third_party/quiche/src/quic/tools/quic_backend_response.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"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
using testing::_;
using testing::AtLeast;
@@ -297,7 +297,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());
@@ -353,7 +353,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.
@@ -364,9 +364,9 @@
TEST_P(QuicSimpleServerSessionTest, 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());
@@ -394,9 +394,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.
@@ -478,7 +478,7 @@
// Receive some data to initiate a incoming stream which should not effect
// creating outgoing streams.
QuicStreamFrame data1(GetNthClientInitiatedBidirectionalId(0), false, 0,
- QuicStringPiece("HT"));
+ quiche::QuicheStringPiece("HT"));
session_->OnStreamFrame(data1);
EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams());
EXPECT_EQ(0u, session_->GetNumOpenOutgoingStreams());
@@ -524,14 +524,14 @@
// Create peer initiated stream should have no problem.
QuicStreamFrame data2(GetNthClientInitiatedBidirectionalId(1), false, 0,
- QuicStringPiece("HT"));
+ quiche::QuicheStringPiece("HT"));
session_->OnStreamFrame(data2);
EXPECT_EQ(2u, session_->GetNumOpenIncomingStreams());
}
TEST_P(QuicSimpleServerSessionTest, OnStreamFrameWithEvenStreamId) {
QuicStreamFrame frame(GetNthServerInitiatedUnidirectionalId(0), false, 0,
- QuicStringPiece());
+ quiche::QuicheStringPiece());
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID,
"Client sent data on server push stream", _));
@@ -651,8 +651,8 @@
} else {
stream_id = GetNthServerInitiatedUnidirectionalId(i - 1);
}
- std::string path =
- partial_push_resource_path + QuicTextUtils::Uint64ToString(i);
+ std::string path = partial_push_resource_path +
+ quiche::QuicheTextUtils::Uint64ToString(i);
std::string url = scheme + "://" + resource_host + path;
QuicUrl resource_url = QuicUrl(url);
std::string body(body_size, 'a');
diff --git a/quic/tools/quic_simple_server_stream.cc b/quic/tools/quic_simple_server_stream.cc
index f821a5d..05a7310 100644
--- a/quic/tools/quic_simple_server_stream.cc
+++ b/quic/tools/quic_simple_server_stream.cc
@@ -14,8 +14,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_text_utils.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_server_session.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;
@@ -265,14 +266,15 @@
if (response->response_type() == QuicBackendResponse::GENERATE_BYTES) {
QUIC_DVLOG(1) << "Stream " << id() << " sending a generate bytes response.";
std::string path = request_headers_[":path"].as_string().substr(1);
- if (!QuicTextUtils::StringToUint64(path, &generate_bytes_length_)) {
+ if (!quiche::QuicheTextUtils::StringToUint64(path,
+ &generate_bytes_length_)) {
QUIC_LOG(ERROR) << "Path is not a number.";
SendNotFoundResponse();
return;
}
SpdyHeaderBlock headers = response->headers().Clone();
headers["content-length"] =
- QuicTextUtils::Uint64ToString(generate_bytes_length_);
+ quiche::QuicheTextUtils::Uint64ToString(generate_bytes_length_);
WriteHeaders(std::move(headers), false, nullptr);
@@ -307,7 +309,7 @@
SpdyHeaderBlock headers;
headers[":status"] = "404";
headers["content-length"] =
- QuicTextUtils::Uint64ToString(strlen(kNotFoundResponseBody));
+ quiche::QuicheTextUtils::Uint64ToString(strlen(kNotFoundResponseBody));
SendHeadersAndBody(std::move(headers), kNotFoundResponseBody);
}
@@ -321,16 +323,16 @@
if (resp_code <= 0) {
headers[":status"] = "500";
} else {
- headers[":status"] = QuicTextUtils::Uint64ToString(resp_code);
+ headers[":status"] = quiche::QuicheTextUtils::Uint64ToString(resp_code);
}
headers["content-length"] =
- QuicTextUtils::Uint64ToString(strlen(kErrorResponseBody));
+ quiche::QuicheTextUtils::Uint64ToString(strlen(kErrorResponseBody));
SendHeadersAndBody(std::move(headers), kErrorResponseBody);
}
void QuicSimpleServerStream::SendIncompleteResponse(
SpdyHeaderBlock response_headers,
- QuicStringPiece body) {
+ quiche::QuicheStringPiece body) {
QUIC_DLOG(INFO) << "Stream " << id() << " writing headers (fin = false) : "
<< response_headers.DebugString();
WriteHeaders(std::move(response_headers), /*fin=*/false, nullptr);
@@ -344,14 +346,14 @@
void QuicSimpleServerStream::SendHeadersAndBody(
SpdyHeaderBlock response_headers,
- QuicStringPiece body) {
+ quiche::QuicheStringPiece body) {
SendHeadersAndBodyAndTrailers(std::move(response_headers), body,
SpdyHeaderBlock());
}
void QuicSimpleServerStream::SendHeadersAndBodyAndTrailers(
SpdyHeaderBlock response_headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
SpdyHeaderBlock response_trailers) {
// Send the headers, with a FIN if there's nothing else to send.
bool send_fin = (body.empty() && response_trailers.empty());
diff --git a/quic/tools/quic_simple_server_stream.h b/quic/tools/quic_simple_server_stream.h
index 594ca02..add4a12 100644
--- a/quic/tools/quic_simple_server_stream.h
+++ b/quic/tools/quic_simple_server_stream.h
@@ -7,9 +7,9 @@
#include "net/third_party/quiche/src/quic/core/http/quic_spdy_server_stream_base.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/quic/tools/quic_backend_response.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_server_backend.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 {
@@ -77,12 +77,12 @@
// Sends the response header and body, but not the fin.
void SendIncompleteResponse(spdy::SpdyHeaderBlock response_headers,
- QuicStringPiece body);
+ quiche::QuicheStringPiece body);
void SendHeadersAndBody(spdy::SpdyHeaderBlock response_headers,
- QuicStringPiece body);
+ quiche::QuicheStringPiece body);
void SendHeadersAndBodyAndTrailers(spdy::SpdyHeaderBlock response_headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
spdy::SpdyHeaderBlock response_trailers);
spdy::SpdyHeaderBlock* request_headers() { return &request_headers_; }
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 50ca84f..b06b752 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -25,6 +25,7 @@
#include "net/third_party/quiche/src/quic/tools/quic_backend_response.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_session.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
using testing::_;
using testing::AnyNumber;
@@ -71,7 +72,7 @@
const std::string& body() const { return body_; }
int content_length() const { return content_length_; }
- QuicStringPiece GetHeader(QuicStringPiece key) const {
+ quiche::QuicheStringPiece GetHeader(quiche::QuicheStringPiece key) const {
auto it = request_headers_.find(key);
DCHECK(it != request_headers_.end());
return it->second;
@@ -585,7 +586,8 @@
spdy::SpdyHeaderBlock request_headers;
// \000 is a way to write the null byte when followed by a literal digit.
- header_list_.OnHeader("content-length", QuicStringPiece("11\00012", 5));
+ header_list_.OnHeader("content-length",
+ quiche::QuicheStringPiece("11\00012", 5));
EXPECT_CALL(*stream_, WriteHeadersMock(false));
EXPECT_CALL(session_, WritevData(_, _, _, _, _))
@@ -602,7 +604,8 @@
spdy::SpdyHeaderBlock request_headers;
// \000 is a way to write the null byte when followed by a literal digit.
- header_list_.OnHeader("content-length", QuicStringPiece("\00012", 3));
+ header_list_.OnHeader("content-length",
+ quiche::QuicheStringPiece("\00012", 3));
EXPECT_CALL(*stream_, WriteHeadersMock(false));
EXPECT_CALL(session_, WritevData(_, _, _, _, _))
@@ -617,7 +620,8 @@
TEST_P(QuicSimpleServerStreamTest, ValidMultipleContentLength) {
spdy::SpdyHeaderBlock request_headers;
// \000 is a way to write the null byte when followed by a literal digit.
- header_list_.OnHeader("content-length", QuicStringPiece("11\00011", 5));
+ header_list_.OnHeader("content-length",
+ quiche::QuicheStringPiece("11\00011", 5));
stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_);
@@ -681,7 +685,7 @@
0x54, 0x54, 0x50, 0x2f, // TTP/
0x31, 0x2e, 0x31, // 1.1
};
- QuicStringPiece data(arr, QUIC_ARRAYSIZE(arr));
+ quiche::QuicheStringPiece data(arr, QUIC_ARRAYSIZE(arr));
QuicStreamFrame frame(stream_->id(), true, 0, data);
// Verify that we don't crash when we get a invalid headers in stream frame.
stream_->OnStreamFrame(frame);
diff --git a/quic/tools/quic_spdy_client_base.cc b/quic/tools/quic_spdy_client_base.cc
index 6b4cc8d..a0d7342 100644
--- a/quic/tools/quic_spdy_client_base.cc
+++ b/quic/tools/quic_spdy_client_base.cc
@@ -11,7 +11,8 @@
#include "net/third_party/quiche/src/quic/core/quic_server_id.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_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;
@@ -24,7 +25,7 @@
QuicSpdyClientBase::QuicDataToResend::QuicDataToResend(
std::unique_ptr<SpdyHeaderBlock> headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin)
: headers_(std::move(headers)), body_(body), fin_(fin) {}
@@ -90,8 +91,8 @@
auto status = response_headers.find(":status");
if (status == response_headers.end()) {
QUIC_LOG(ERROR) << "Missing :status response header";
- } else if (!QuicTextUtils::StringToInt(status->second,
- &latest_response_code_)) {
+ } else if (!quiche::QuicheTextUtils::StringToInt(status->second,
+ &latest_response_code_)) {
QUIC_LOG(ERROR) << "Invalid :status response header: " << status->second;
}
latest_response_headers_ = response_headers.DebugString();
@@ -113,13 +114,13 @@
}
void QuicSpdyClientBase::SendRequest(const SpdyHeaderBlock& headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin) {
if (GetQuicFlag(FLAGS_quic_client_convert_http_header_name_to_lowercase)) {
QUIC_CODE_COUNT(quic_client_convert_http_header_name_to_lowercase);
SpdyHeaderBlock sanitized_headers;
for (const auto& p : headers) {
- sanitized_headers[QuicTextUtils::ToLower(p.first)] = p.second;
+ sanitized_headers[quiche::QuicheTextUtils::ToLower(p.first)] = p.second;
}
SendRequestInternal(std::move(sanitized_headers), body, fin);
@@ -129,7 +130,7 @@
}
void QuicSpdyClientBase::SendRequestInternal(SpdyHeaderBlock sanitized_headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin) {
QuicClientPushPromiseIndex::TryHandle* handle;
QuicAsyncStatus rv =
@@ -153,7 +154,7 @@
void QuicSpdyClientBase::SendRequestAndWaitForResponse(
const SpdyHeaderBlock& headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin) {
SendRequest(headers, body, fin);
while (WaitForEvents()) {
@@ -217,7 +218,7 @@
}
void QuicSpdyClientBase::AddPromiseDataToResend(const SpdyHeaderBlock& headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin) {
std::unique_ptr<SpdyHeaderBlock> new_headers(
new SpdyHeaderBlock(headers.Clone()));
diff --git a/quic/tools/quic_spdy_client_base.h b/quic/tools/quic_spdy_client_base.h
index d953038..09785f3 100644
--- a/quic/tools/quic_spdy_client_base.h
+++ b/quic/tools/quic_spdy_client_base.h
@@ -16,8 +16,8 @@
#include "net/third_party/quiche/src/quic/core/http/quic_spdy_client_stream.h"
#include "net/third_party/quiche/src/quic/core/quic_config.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
#include "net/third_party/quiche/src/quic/tools/quic_client_base.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -47,7 +47,7 @@
public:
// |headers| may be null, since it's possible to send data without headers.
QuicDataToResend(std::unique_ptr<spdy::SpdyHeaderBlock> headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin);
QuicDataToResend(const QuicDataToResend&) = delete;
QuicDataToResend& operator=(const QuicDataToResend&) = delete;
@@ -60,7 +60,7 @@
protected:
std::unique_ptr<spdy::SpdyHeaderBlock> headers_;
- QuicStringPiece body_;
+ quiche::QuicheStringPiece body_;
bool fin_;
};
@@ -86,12 +86,12 @@
// Sends an HTTP request and does not wait for response before returning.
void SendRequest(const spdy::SpdyHeaderBlock& headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin);
// Sends an HTTP request and waits for response before returning.
void SendRequestAndWaitForResponse(const spdy::SpdyHeaderBlock& headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin);
// Sends a request simple GET for each URL in |url_list|, and then waits for
@@ -159,7 +159,7 @@
void ResendSavedData() override;
void AddPromiseDataToResend(const spdy::SpdyHeaderBlock& headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin);
bool HasActiveRequests() override;
@@ -168,7 +168,7 @@
class ClientQuicDataToResend : public QuicDataToResend {
public:
ClientQuicDataToResend(std::unique_ptr<spdy::SpdyHeaderBlock> headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin,
QuicSpdyClientBase* client)
: QuicDataToResend(std::move(headers), body, fin), client_(client) {
@@ -187,7 +187,7 @@
};
void SendRequestInternal(spdy::SpdyHeaderBlock sanitized_headers,
- QuicStringPiece body,
+ quiche::QuicheStringPiece body,
bool fin);
// Index of pending promised streams. Must outlive |session_|.
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index 30018c2..e790b54 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -54,18 +54,17 @@
#include "net/third_party/quiche/src/quic/core/quic_versions.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_default_proof_providers.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_system_event_loop.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/third_party/quiche/src/quic/tools/fake_proof_verifier.h"
#include "net/third_party/quiche/src/quic/tools/quic_url.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 {
-using quic::QuicStringPiece;
-using quic::QuicTextUtils;
using quic::QuicUrl;
+using quiche::QuicheStringPiece;
+using quiche::QuicheTextUtils;
} // namespace
@@ -253,7 +252,7 @@
if (!GetQuicFlag(FLAGS_body_hex).empty()) {
DCHECK(GetQuicFlag(FLAGS_body).empty())
<< "Only set one of --body and --body_hex.";
- body = QuicTextUtils::HexDecode(GetQuicFlag(FLAGS_body_hex));
+ body = QuicheTextUtils::HexDecode(GetQuicFlag(FLAGS_body_hex));
}
// Construct a GET or POST request for supplied URL.
@@ -265,14 +264,14 @@
// Append any additional headers supplied on the command line.
const std::string headers = GetQuicFlag(FLAGS_headers);
- for (QuicStringPiece sp : QuicTextUtils::Split(headers, ';')) {
- QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&sp);
+ for (QuicheStringPiece sp : QuicheTextUtils::Split(headers, ';')) {
+ QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&sp);
if (sp.empty()) {
continue;
}
- std::vector<QuicStringPiece> kv = QuicTextUtils::Split(sp, ':');
- QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[0]);
- QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[1]);
+ std::vector<QuicheStringPiece> kv = QuicheTextUtils::Split(sp, ':');
+ QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[0]);
+ QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[1]);
header_block[kv[0]] = kv[1];
}
@@ -290,8 +289,8 @@
if (!GetQuicFlag(FLAGS_body_hex).empty()) {
// Print the user provided hex, rather than binary body.
std::cout << "body:\n"
- << QuicTextUtils::HexDump(
- QuicTextUtils::HexDecode(GetQuicFlag(FLAGS_body_hex)))
+ << QuicheTextUtils::HexDump(QuicheTextUtils::HexDecode(
+ GetQuicFlag(FLAGS_body_hex)))
<< std::endl;
} else {
std::cout << "body: " << body << std::endl;
@@ -311,7 +310,7 @@
if (!GetQuicFlag(FLAGS_body_hex).empty()) {
// Assume response is binary data.
std::cout << "body:\n"
- << QuicTextUtils::HexDump(response_body) << std::endl;
+ << QuicheTextUtils::HexDump(response_body) << std::endl;
} else {
std::cout << "body: " << response_body << std::endl;
}
diff --git a/quic/tools/quic_transport_simple_server_dispatcher.cc b/quic/tools/quic_transport_simple_server_dispatcher.cc
index 2302b67..59c14d2 100644
--- a/quic/tools/quic_transport_simple_server_dispatcher.cc
+++ b/quic/tools/quic_transport_simple_server_dispatcher.cc
@@ -11,6 +11,7 @@
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/core/quic_versions.h"
#include "net/third_party/quiche/src/quic/tools/quic_transport_simple_server_session.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -35,7 +36,7 @@
QuicSession* QuicTransportSimpleServerDispatcher::CreateQuicSession(
QuicConnectionId server_connection_id,
const QuicSocketAddress& peer_address,
- QuicStringPiece /*alpn*/,
+ quiche::QuicheStringPiece /*alpn*/,
const ParsedQuicVersion& version) {
auto connection = std::make_unique<QuicConnection>(
server_connection_id, peer_address, helper(), alarm_factory(), writer(),
diff --git a/quic/tools/quic_transport_simple_server_dispatcher.h b/quic/tools/quic_transport_simple_server_dispatcher.h
index f3e1b47..4c134ad 100644
--- a/quic/tools/quic_transport_simple_server_dispatcher.h
+++ b/quic/tools/quic_transport_simple_server_dispatcher.h
@@ -8,6 +8,7 @@
#include "url/origin.h"
#include "net/third_party/quiche/src/quic/core/quic_dispatcher.h"
#include "net/third_party/quiche/src/quic/tools/quic_transport_simple_server_session.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -28,7 +29,7 @@
protected:
QuicSession* CreateQuicSession(QuicConnectionId server_connection_id,
const QuicSocketAddress& peer_address,
- QuicStringPiece alpn,
+ quiche::QuicheStringPiece alpn,
const ParsedQuicVersion& version) override;
std::vector<url::Origin> accepted_origins_;
diff --git a/quic/tools/quic_transport_simple_server_session.cc b/quic/tools/quic_transport_simple_server_session.cc
index b1221ae..9fe3dfd 100644
--- a/quic/tools/quic_transport_simple_server_session.cc
+++ b/quic/tools/quic_transport_simple_server_session.cc
@@ -12,8 +12,6 @@
#include "net/third_party/quiche/src/quic/core/quic_versions.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_string_piece.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/third_party/quiche/src/quic/quic_transport/quic_transport_protocol.h"
#include "net/third_party/quiche/src/quic/quic_transport/quic_transport_stream.h"
diff --git a/quic/tools/quic_transport_simple_server_session.h b/quic/tools/quic_transport_simple_server_session.h
index a7bc28d..a2dd6be 100644
--- a/quic/tools/quic_transport_simple_server_session.h
+++ b/quic/tools/quic_transport_simple_server_session.h
@@ -13,7 +13,6 @@
#include "net/third_party/quiche/src/quic/core/quic_versions.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
#include "net/third_party/quiche/src/quic/quic_transport/quic_transport_server_session.h"
#include "net/third_party/quiche/src/quic/quic_transport/quic_transport_stream.h"
diff --git a/quic/tools/quic_url.cc b/quic/tools/quic_url.cc
index 4094ffe..438847c 100644
--- a/quic/tools/quic_url.cc
+++ b/quic/tools/quic_url.cc
@@ -4,22 +4,24 @@
#include "net/third_party/quiche/src/quic/tools/quic_url.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"
namespace quic {
static constexpr size_t kMaxHostNameLength = 256;
-QuicUrl::QuicUrl(QuicStringPiece url) : url_(static_cast<std::string>(url)) {}
+QuicUrl::QuicUrl(quiche::QuicheStringPiece url)
+ : url_(static_cast<std::string>(url)) {}
-QuicUrl::QuicUrl(QuicStringPiece url, QuicStringPiece default_scheme)
+QuicUrl::QuicUrl(quiche::QuicheStringPiece url,
+ quiche::QuicheStringPiece default_scheme)
: QuicUrl(url) {
if (url_.has_scheme()) {
return;
}
- url_ = GURL(QuicStrCat(default_scheme, "://", url));
+ url_ = GURL(quiche::QuicheStrCat(default_scheme, "://", url));
}
std::string QuicUrl::ToString() const {
@@ -51,7 +53,7 @@
if (port == url::PORT_UNSPECIFIED) {
return host;
}
- return QuicStrCat(host, ":", port);
+ return quiche::QuicheStrCat(host, ":", port);
}
std::string QuicUrl::PathParamsQuery() const {
diff --git a/quic/tools/quic_url.h b/quic/tools/quic_url.h
index da1b69d..4b057db 100644
--- a/quic/tools/quic_url.h
+++ b/quic/tools/quic_url.h
@@ -9,7 +9,7 @@
#include "url/gurl.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 {
@@ -24,11 +24,12 @@
// NOTE: If |url| doesn't have a scheme, it will have an empty scheme
// field. If that's not what you want, use the QuicUrlImpl(url,
// default_scheme) form below.
- explicit QuicUrl(QuicStringPiece url);
+ explicit QuicUrl(quiche::QuicheStringPiece url);
// Constructs a QuicUrlImpl from |url|, assuming that the scheme for the URL
// is |default_scheme| if there is no scheme specified in |url|.
- QuicUrl(QuicStringPiece url, QuicStringPiece default_scheme);
+ QuicUrl(quiche::QuicheStringPiece url,
+ quiche::QuicheStringPiece default_scheme);
// Returns false if the URL is not valid.
bool IsValid() const;
diff --git a/quic/tools/quic_url_test.cc b/quic/tools/quic_url_test.cc
index 608fdb1..8ffee25 100644
--- a/quic/tools/quic_url_test.cc
+++ b/quic/tools/quic_url_test.cc
@@ -6,7 +6,6 @@
#include <string>
-#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"
namespace quic {
