Pass base::StringPiece by value, not reference, in //net
This is the result of
git grep -l 'const base::StringPiece&' | \
xargs sed -i -e 's/const base::StringPiece&/base::StringPiece/g'
plus one manual fixup in pem.cc because that file had a using
declaration. Per the header, it should be passed by value but a lot of
this code was written to older expectations.
Change-Id: I9e24b805114805aae2e907b6081359b486b576bc
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3971168
Reviewed-by: Adam Rice <[email protected]>
Auto-Submit: David Benjamin <[email protected]>
Commit-Queue: Adam Rice <[email protected]>
Cr-Commit-Position: refs/heads/main@{#1062739}
diff --git a/net/base/ip_address.cc b/net/base/ip_address.cc
index 7ac6331..28e210ef 100644
--- a/net/base/ip_address.cc
+++ b/net/base/ip_address.cc
@@ -112,7 +112,7 @@
return false;
}
-bool ParseIPLiteralToBytes(const base::StringPiece& ip_literal,
+bool ParseIPLiteralToBytes(base::StringPiece ip_literal,
IPAddressBytes* bytes) {
// |ip_literal| could be either an IPv4 or an IPv6 literal. If it contains
// a colon however, it must be an IPv6 address.
@@ -287,7 +287,7 @@
return false;
}
-bool IPAddress::AssignFromIPLiteral(const base::StringPiece& ip_literal) {
+bool IPAddress::AssignFromIPLiteral(base::StringPiece ip_literal) {
bool success = ParseIPLiteralToBytes(ip_literal, &ip_address_);
if (!success)
ip_address_.Resize(0);
@@ -454,7 +454,7 @@
return true;
}
-bool ParseURLHostnameToAddress(const base::StringPiece& hostname,
+bool ParseURLHostnameToAddress(base::StringPiece hostname,
IPAddress* ip_address) {
if (hostname.size() >= 2 && hostname.front() == '[' &&
hostname.back() == ']') {
diff --git a/net/base/ip_address.h b/net/base/ip_address.h
index ea00438..a9782d8 100644
--- a/net/base/ip_address.h
+++ b/net/base/ip_address.h
@@ -185,7 +185,7 @@
//
// When parsing fails, the original value of |this| will be overwritten such
// that |this->empty()| and |!this->IsValid()|.
- [[nodiscard]] bool AssignFromIPLiteral(const base::StringPiece& ip_literal);
+ [[nodiscard]] bool AssignFromIPLiteral(base::StringPiece ip_literal);
// Returns the underlying bytes.
const IPAddressBytes& bytes() const { return ip_address_; }
@@ -274,7 +274,7 @@
// surrounded by brackets as in [::1]. On failure |ip_address| may have been
// overwritten and could contain an invalid IPAddress.
[[nodiscard]] NET_EXPORT bool ParseURLHostnameToAddress(
- const base::StringPiece& hostname,
+ base::StringPiece hostname,
IPAddress* ip_address);
// Returns number of matching initial bits between the addresses |a1| and |a2|.
diff --git a/net/base/mime_util.cc b/net/base/mime_util.cc
index eb9774d..24305ef 100644
--- a/net/base/mime_util.cc
+++ b/net/base/mime_util.cc
@@ -261,7 +261,7 @@
}
static base::FilePath::StringType StringToFilePathStringType(
- const base::StringPiece& string_piece) {
+ base::StringPiece string_piece) {
#if BUILDFLAG(IS_WIN)
return base::UTF8ToWide(string_piece);
#else
@@ -759,7 +759,7 @@
if (base::StartsWith(cur_mime_type, mime_type,
base::CompareCase::INSENSITIVE_ASCII) &&
(prefix_match || (cur_mime_type.length() == mime_type.length()))) {
- for (const base::StringPiece& this_extension : base::SplitStringPiece(
+ for (base::StringPiece this_extension : base::SplitStringPiece(
mapping.extensions, ",", base::TRIM_WHITESPACE,
base::SPLIT_WANT_ALL)) {
extensions->insert(StringToFilePathStringType(this_extension));
diff --git a/net/base/parse_number.cc b/net/base/parse_number.cc
index 4859bff..2abd610 100644
--- a/net/base/parse_number.cc
+++ b/net/base/parse_number.cc
@@ -16,21 +16,21 @@
// consistent interface to StringToXXX() that calls the appropriate //base
// version. This simplifies writing generic code with a template.
-bool StringToNumber(const base::StringPiece& input, int32_t* output) {
+bool StringToNumber(base::StringPiece input, int32_t* output) {
// This assumes ints are 32-bits (will fail compile if that ever changes).
return base::StringToInt(input, output);
}
-bool StringToNumber(const base::StringPiece& input, uint32_t* output) {
+bool StringToNumber(base::StringPiece input, uint32_t* output) {
// This assumes ints are 32-bits (will fail compile if that ever changes).
return base::StringToUint(input, output);
}
-bool StringToNumber(const base::StringPiece& input, int64_t* output) {
+bool StringToNumber(base::StringPiece input, int64_t* output) {
return base::StringToInt64(input, output);
}
-bool StringToNumber(const base::StringPiece& input, uint64_t* output) {
+bool StringToNumber(base::StringPiece input, uint64_t* output) {
return base::StringToUint64(input, output);
}
@@ -41,7 +41,7 @@
}
template <typename T>
-bool ParseIntHelper(const base::StringPiece& input,
+bool ParseIntHelper(base::StringPiece input,
ParseIntFormat format,
T* output,
ParseIntError* optional_error) {
@@ -95,28 +95,28 @@
} // namespace
-bool ParseInt32(const base::StringPiece& input,
+bool ParseInt32(base::StringPiece input,
ParseIntFormat format,
int32_t* output,
ParseIntError* optional_error) {
return ParseIntHelper(input, format, output, optional_error);
}
-bool ParseInt64(const base::StringPiece& input,
+bool ParseInt64(base::StringPiece input,
ParseIntFormat format,
int64_t* output,
ParseIntError* optional_error) {
return ParseIntHelper(input, format, output, optional_error);
}
-bool ParseUint32(const base::StringPiece& input,
+bool ParseUint32(base::StringPiece input,
uint32_t* output,
ParseIntError* optional_error) {
return ParseIntHelper(input, ParseIntFormat::NON_NEGATIVE, output,
optional_error);
}
-bool ParseUint64(const base::StringPiece& input,
+bool ParseUint64(base::StringPiece input,
uint64_t* output,
ParseIntError* optional_error) {
return ParseIntHelper(input, ParseIntFormat::NON_NEGATIVE, output,
diff --git a/net/base/parse_number.h b/net/base/parse_number.h
index d6adf38..7668bb2 100644
--- a/net/base/parse_number.h
+++ b/net/base/parse_number.h
@@ -82,13 +82,13 @@
// |optional_error| was non-null, then it is filled with the reason for the
// failure.
[[nodiscard]] NET_EXPORT bool ParseInt32(
- const base::StringPiece& input,
+ base::StringPiece input,
ParseIntFormat format,
int32_t* output,
ParseIntError* optional_error = nullptr);
[[nodiscard]] NET_EXPORT bool ParseInt64(
- const base::StringPiece& input,
+ base::StringPiece input,
ParseIntFormat format,
int64_t* output,
ParseIntError* optional_error = nullptr);
@@ -98,12 +98,12 @@
// These are equivalent to calling ParseInt*() with a format string of
// ParseIntFormat::NON_NEGATIVE and unsigned output types.
[[nodiscard]] NET_EXPORT bool ParseUint32(
- const base::StringPiece& input,
+ base::StringPiece input,
uint32_t* output,
ParseIntError* optional_error = nullptr);
[[nodiscard]] NET_EXPORT bool ParseUint64(
- const base::StringPiece& input,
+ base::StringPiece input,
uint64_t* output,
ParseIntError* optional_error = nullptr);
diff --git a/net/base/parse_number_unittest.cc b/net/base/parse_number_unittest.cc
index ccde98f8..7a78de5 100644
--- a/net/base/parse_number_unittest.cc
+++ b/net/base/parse_number_unittest.cc
@@ -60,7 +60,7 @@
// This wrapper calls func() and expects the result to match |expected_output|.
template <typename OutputType, typename ParseFunc, typename ExpectationType>
void ExpectParseIntSuccess(ParseFunc func,
- const base::StringPiece& input,
+ base::StringPiece input,
ParseIntFormat format,
ExpectationType expected_output) {
// Try parsing without specifying an error output - expecting success.
@@ -83,7 +83,7 @@
// This wrapper calls func() and expects the failure to match |expected_error|.
template <typename OutputType, typename ParseFunc>
void ExpectParseIntFailure(ParseFunc func,
- const base::StringPiece& input,
+ base::StringPiece input,
ParseIntFormat format,
ParseIntError expected_error) {
const OutputType kBogusOutput(23614);
@@ -213,9 +213,8 @@
// TestParseIntUsingFormat() expects a functor that has a |format|
// parameter. For ParseUint*() there is no such parameter. For all intents
// and purposes can just fix it to NON_NEGATIVE and re-use that test driver.
- auto func_adapter = [&func](const base::StringPiece& input,
- ParseIntFormat format, T* output,
- ParseIntError* optional_error) {
+ auto func_adapter = [&func](base::StringPiece input, ParseIntFormat format,
+ T* output, ParseIntError* optional_error) {
EXPECT_EQ(ParseIntFormat::NON_NEGATIVE, format);
return func(input, output, optional_error);
};
diff --git a/net/base/registry_controlled_domains/registry_controlled_domain.cc b/net/base/registry_controlled_domains/registry_controlled_domain.cc
index be72914..7fbc97c 100644
--- a/net/base/registry_controlled_domains/registry_controlled_domain.cc
+++ b/net/base/registry_controlled_domains/registry_controlled_domain.cc
@@ -339,8 +339,7 @@
return true;
// Check for a domain and registry match.
- const base::StringPiece& domain1 =
- GetDomainAndRegistryAsStringPiece(host1, filter);
+ base::StringPiece domain1 = GetDomainAndRegistryAsStringPiece(host1, filter);
return !domain1.empty() &&
(domain1 == GetDomainAndRegistryAsStringPiece(host2, filter));
}
diff --git a/net/cert/ct_log_verifier.cc b/net/cert/ct_log_verifier.cc
index 44eb1ab8..77797dd 100644
--- a/net/cert/ct_log_verifier.cc
+++ b/net/cert/ct_log_verifier.cc
@@ -57,7 +57,7 @@
// static
scoped_refptr<const CTLogVerifier> CTLogVerifier::Create(
- const base::StringPiece& public_key,
+ base::StringPiece public_key,
std::string description) {
auto result = base::WrapRefCounted(new CTLogVerifier(std::move(description)));
if (!result->Init(public_key))
@@ -269,7 +269,7 @@
EVP_PKEY_free(public_key_);
}
-bool CTLogVerifier::Init(const base::StringPiece& public_key) {
+bool CTLogVerifier::Init(base::StringPiece public_key) {
crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
CBS cbs;
@@ -306,8 +306,8 @@
return true;
}
-bool CTLogVerifier::VerifySignature(const base::StringPiece& data_to_sign,
- const base::StringPiece& signature) const {
+bool CTLogVerifier::VerifySignature(base::StringPiece data_to_sign,
+ base::StringPiece signature) const {
crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
const EVP_MD* hash_alg = GetEvpAlg(hash_algorithm_);
diff --git a/net/cert/ct_log_verifier.h b/net/cert/ct_log_verifier.h
index 6c67f97b..e0c39a19 100644
--- a/net/cert/ct_log_verifier.h
+++ b/net/cert/ct_log_verifier.h
@@ -36,9 +36,8 @@
// using |public_key|, which is a DER-encoded SubjectPublicKeyInfo.
// If |public_key| refers to an unsupported public key, returns NULL.
// |description| is a textual description of the log.
- static scoped_refptr<const CTLogVerifier> Create(
- const base::StringPiece& public_key,
- std::string description);
+ static scoped_refptr<const CTLogVerifier> Create(base::StringPiece public_key,
+ std::string description);
// Returns the log's key ID (RFC6962, Section 3.2)
const std::string& key_id() const { return key_id_; }
@@ -77,13 +76,13 @@
~CTLogVerifier();
// Performs crypto-library specific initialization.
- bool Init(const base::StringPiece& public_key);
+ bool Init(base::StringPiece public_key);
// Performs the underlying verification using the selected public key. Note
// that |signature| contains the raw signature data (eg: without any
// DigitallySigned struct encoding).
- bool VerifySignature(const base::StringPiece& data_to_sign,
- const base::StringPiece& signature) const;
+ bool VerifySignature(base::StringPiece data_to_sign,
+ base::StringPiece signature) const;
// Returns true if the signature and hash algorithms in |signature|
// match those of the log
diff --git a/net/cert/ct_serialization.cc b/net/cert/ct_serialization.cc
index 89c77d31..8cf2d4d5 100644
--- a/net/cert/ct_serialization.cc
+++ b/net/cert/ct_serialization.cc
@@ -376,8 +376,7 @@
return true;
}
-bool EncodeSCTListForTesting(const base::StringPiece& sct,
- std::string* output) {
+bool EncodeSCTListForTesting(base::StringPiece sct, std::string* output) {
bssl::ScopedCBB encoded_sct, output_cbb;
CBB encoded_sct_child, output_child;
if (!CBB_init(encoded_sct.get(), 64) || !CBB_init(output_cbb.get(), 64) ||
diff --git a/net/cert/ct_serialization.h b/net/cert/ct_serialization.h
index c3aded5..54c5587 100644
--- a/net/cert/ct_serialization.h
+++ b/net/cert/ct_serialization.h
@@ -93,7 +93,7 @@
std::string* output);
// Writes an SCTList into |output|, containing a single |sct|.
-NET_EXPORT_PRIVATE bool EncodeSCTListForTesting(const base::StringPiece& sct,
+NET_EXPORT_PRIVATE bool EncodeSCTListForTesting(base::StringPiece sct,
std::string* output);
} // namespace net::ct
diff --git a/net/cert/pem.cc b/net/cert/pem.cc
index 82f77b5..2601bc85 100644
--- a/net/cert/pem.cc
+++ b/net/cert/pem.cc
@@ -28,7 +28,7 @@
};
PEMTokenizer::PEMTokenizer(
- const StringPiece& str,
+ StringPiece str,
const std::vector<std::string>& allowed_block_types) {
Init(str, allowed_block_types);
}
@@ -83,7 +83,7 @@
return false;
}
-void PEMTokenizer::Init(const StringPiece& str,
+void PEMTokenizer::Init(StringPiece str,
const std::vector<std::string>& allowed_block_types) {
str_ = str;
pos_ = 0;
diff --git a/net/cert/pem.h b/net/cert/pem.h
index c8cf31cb..f84771c2 100644
--- a/net/cert/pem.h
+++ b/net/cert/pem.h
@@ -24,7 +24,7 @@
// Create a new PEMTokenizer that iterates through |str| searching for
// instances of PEM encoded blocks that are of the |allowed_block_types|.
// |str| must remain valid for the duration of the PEMTokenizer.
- PEMTokenizer(const base::StringPiece& str,
+ PEMTokenizer(base::StringPiece str,
const std::vector<std::string>& allowed_block_types);
PEMTokenizer(const PEMTokenizer&) = delete;
@@ -48,7 +48,7 @@
const std::string& data() const { return data_; }
private:
- void Init(const base::StringPiece& str,
+ void Init(base::StringPiece str,
const std::vector<std::string>& allowed_block_types);
// A simple cache of the allowed PEM header and footer for a given PEM
diff --git a/net/cert/x509_certificate.cc b/net/cert/x509_certificate.cc
index be2c1d3a..e906f30 100644
--- a/net/cert/x509_certificate.cc
+++ b/net/cert/x509_certificate.cc
@@ -62,7 +62,7 @@
// Utility to split |src| on the first occurrence of |c|, if any. |right| will
// either be empty if |c| was not found, or will contain the remainder of the
// string including the split character itself.
-void SplitOnChar(const base::StringPiece& src,
+void SplitOnChar(base::StringPiece src,
char c,
base::StringPiece* left,
base::StringPiece* right) {
diff --git a/net/cert/x509_util.cc b/net/cert/x509_util.cc
index 537ff4ac..5a377417 100644
--- a/net/cert/x509_util.cc
+++ b/net/cert/x509_util.cc
@@ -385,8 +385,7 @@
CRYPTO_BUFFER_new(data.data(), data.size(), GetBufferPool()));
}
-bssl::UniquePtr<CRYPTO_BUFFER> CreateCryptoBuffer(
- const base::StringPiece& data) {
+bssl::UniquePtr<CRYPTO_BUFFER> CreateCryptoBuffer(base::StringPiece data) {
return bssl::UniquePtr<CRYPTO_BUFFER>(
CRYPTO_BUFFER_new(reinterpret_cast<const uint8_t*>(data.data()),
data.size(), GetBufferPool()));
diff --git a/net/cert/x509_util.h b/net/cert/x509_util.h
index f2a6156..6c1adce 100644
--- a/net/cert/x509_util.h
+++ b/net/cert/x509_util.h
@@ -112,7 +112,7 @@
// Creates a CRYPTO_BUFFER in the same pool returned by GetBufferPool.
NET_EXPORT bssl::UniquePtr<CRYPTO_BUFFER> CreateCryptoBuffer(
- const base::StringPiece& data);
+ base::StringPiece data);
// Overload with no definition, to disallow creating a CRYPTO_BUFFER from a
// char* due to StringPiece implicit ctor.
diff --git a/net/disk_cache/simple/simple_util.cc b/net/disk_cache/simple/simple_util.cc
index b29ff3f..d823335 100644
--- a/net/disk_cache/simple/simple_util.cc
+++ b/net/disk_cache/simple/simple_util.cc
@@ -40,7 +40,7 @@
return hash_key_str;
}
-bool GetEntryHashKeyFromHexString(const base::StringPiece& hash_key,
+bool GetEntryHashKeyFromHexString(base::StringPiece hash_key,
uint64_t* hash_key_out) {
if (hash_key.size() != kEntryHashKeyAsHexStringSize) {
return false;
diff --git a/net/disk_cache/simple/simple_util.h b/net/disk_cache/simple/simple_util.h
index 459a2a1..5857e2b 100644
--- a/net/disk_cache/simple/simple_util.h
+++ b/net/disk_cache/simple/simple_util.h
@@ -33,9 +33,8 @@
// Parses the |hash_key| string into a uint64_t buffer.
// |hash_key| string must be of the form: FFFFFFFFFFFFFFFF .
-NET_EXPORT_PRIVATE bool GetEntryHashKeyFromHexString(
- const base::StringPiece& hash_key,
- uint64_t* hash_key_out);
+NET_EXPORT_PRIVATE bool GetEntryHashKeyFromHexString(base::StringPiece hash_key,
+ uint64_t* hash_key_out);
// Given a |key| for a (potential) entry in the simple backend and the |index|
// of a stream on that entry, returns the filename in which that stream would be
diff --git a/net/dns/dns_query.cc b/net/dns/dns_query.cc
index 6f93a81..5d586b0e 100644
--- a/net/dns/dns_query.cc
+++ b/net/dns/dns_query.cc
@@ -101,7 +101,7 @@
// bit, which directs the name server to pursue query recursively, and sets
// the QDCOUNT to 1, meaning the question section has a single entry.
DnsQuery::DnsQuery(uint16_t id,
- const base::StringPiece& qname,
+ base::StringPiece qname,
uint16_t qtype,
const OptRecordRdata* opt_rdata,
PaddingStrategy padding_strategy)
diff --git a/net/dns/dns_query.h b/net/dns/dns_query.h
index 7e2045d..3fa6599 100644
--- a/net/dns/dns_query.h
+++ b/net/dns/dns_query.h
@@ -48,7 +48,7 @@
// If |opt_rdata| is not null, an OPT record will be added to the "Additional"
// section of the query.
DnsQuery(uint16_t id,
- const base::StringPiece& qname,
+ base::StringPiece qname,
uint16_t qtype,
const OptRecordRdata* opt_rdata = nullptr,
PaddingStrategy padding_strategy = PaddingStrategy::NONE);
diff --git a/net/dns/dns_response.cc b/net/dns/dns_response.cc
index d1f1ef7..7523bc3 100644
--- a/net/dns/dns_response.cc
+++ b/net/dns/dns_response.cc
@@ -541,7 +541,7 @@
bool DnsResponse::WriteQuestion(base::BigEndianWriter* writer,
const DnsQuery& query) {
- const base::StringPiece& question = query.question();
+ base::StringPiece question = query.question();
return writer->WriteBytes(question.data(), question.size());
}
diff --git a/net/dns/dns_util.cc b/net/dns/dns_util.cc
index a5dfa19..f1e9912 100644
--- a/net/dns/dns_util.cc
+++ b/net/dns/dns_util.cc
@@ -44,7 +44,7 @@
namespace {
// Based on DJB's public domain code.
-bool DNSDomainFromDot(const base::StringPiece& dotted,
+bool DNSDomainFromDot(base::StringPiece dotted,
bool is_unrestricted,
std::string* out) {
const char* buf = dotted.data();
@@ -120,21 +120,20 @@
} // namespace
-bool DNSDomainFromDot(const base::StringPiece& dotted, std::string* out) {
+bool DNSDomainFromDot(base::StringPiece dotted, std::string* out) {
return DNSDomainFromDot(dotted, false /* is_unrestricted */, out);
}
-bool DNSDomainFromUnrestrictedDot(const base::StringPiece& dotted,
- std::string* out) {
+bool DNSDomainFromUnrestrictedDot(base::StringPiece dotted, std::string* out) {
return DNSDomainFromDot(dotted, true /* is_unrestricted */, out);
}
-bool IsValidDNSDomain(const base::StringPiece& dotted) {
+bool IsValidDNSDomain(base::StringPiece dotted) {
std::string dns_formatted;
return DNSDomainFromDot(dotted, &dns_formatted);
}
-bool IsValidUnrestrictedDNSDomain(const base::StringPiece& dotted) {
+bool IsValidUnrestrictedDNSDomain(base::StringPiece dotted) {
std::string dns_formatted;
return DNSDomainFromUnrestrictedDot(dotted, &dns_formatted);
}
diff --git a/net/dns/dns_util.h b/net/dns/dns_util.h
index ab9233e8..4d5c649 100644
--- a/net/dns/dns_util.h
+++ b/net/dns/dns_util.h
@@ -32,8 +32,7 @@
//
// dotted: a string in dotted form: "www.google.com"
// out: a result in DNS form: "\x03www\x06google\x03com\x00"
-NET_EXPORT bool DNSDomainFromDot(const base::StringPiece& dotted,
- std::string* out);
+NET_EXPORT bool DNSDomainFromDot(base::StringPiece dotted, std::string* out);
// DNSDomainFromUnrestrictedDot - convert a domain string to DNS format. Adapted
// from DJB's public domain DNS library. No validation of the characters in
@@ -41,16 +40,15 @@
//
// dotted: a string in dotted form: "Foo Printer._tcp.local"
// out: a result in DNS form: "\x0bFoo Printer\x04_tcp\x05local\x00"
-NET_EXPORT bool DNSDomainFromUnrestrictedDot(const base::StringPiece& dotted,
+NET_EXPORT bool DNSDomainFromUnrestrictedDot(base::StringPiece dotted,
std::string* out);
// Checks that a hostname is valid. Simple wrapper around DNSDomainFromDot.
-NET_EXPORT_PRIVATE bool IsValidDNSDomain(const base::StringPiece& dotted);
+NET_EXPORT_PRIVATE bool IsValidDNSDomain(base::StringPiece dotted);
// Checks that a hostname is valid. Simple wrapper around
// DNSDomainFromUnrestrictedDot.
-NET_EXPORT_PRIVATE bool IsValidUnrestrictedDNSDomain(
- const base::StringPiece& dotted);
+NET_EXPORT_PRIVATE bool IsValidUnrestrictedDNSDomain(base::StringPiece dotted);
// Returns true if the character is valid in a DNS hostname label, whether in
// the first position or later in the label.
diff --git a/net/dns/mock_host_resolver.cc b/net/dns/mock_host_resolver.cc
index 9901ea3..7afe597 100644
--- a/net/dns/mock_host_resolver.cc
+++ b/net/dns/mock_host_resolver.cc
@@ -120,7 +120,7 @@
int ParseAddressList(base::StringPiece host_list,
std::vector<net::IPEndPoint>* ip_endpoints) {
ip_endpoints->clear();
- for (const base::StringPiece& address : base::SplitStringPiece(
+ for (base::StringPiece address : base::SplitStringPiece(
host_list, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
IPAddress ip_address;
if (!ip_address.AssignFromIPLiteral(address)) {
diff --git a/net/dns/record_rdata.cc b/net/dns/record_rdata.cc
index 27f32dcd..102591d96 100644
--- a/net/dns/record_rdata.cc
+++ b/net/dns/record_rdata.cc
@@ -24,7 +24,7 @@
// Minimal HTTPS rdata is 2 octets priority + 1 octet empty name.
static constexpr size_t kHttpsRdataMinimumSize = 3;
-bool RecordRdata::HasValidSize(const base::StringPiece& data, uint16_t type) {
+bool RecordRdata::HasValidSize(base::StringPiece data, uint16_t type) {
switch (type) {
case dns_protocol::kTypeSRV:
return data.size() >= kSrvRecordMinimumSize;
@@ -53,7 +53,7 @@
// static
std::unique_ptr<SrvRecordRdata> SrvRecordRdata::Create(
- const base::StringPiece& data,
+ base::StringPiece data,
const DnsRecordParser& parser) {
if (!HasValidSize(data, kType))
return nullptr;
@@ -92,7 +92,7 @@
// static
std::unique_ptr<ARecordRdata> ARecordRdata::Create(
- const base::StringPiece& data,
+ base::StringPiece data,
const DnsRecordParser& parser) {
if (!HasValidSize(data, kType))
return nullptr;
@@ -119,7 +119,7 @@
// static
std::unique_ptr<AAAARecordRdata> AAAARecordRdata::Create(
- const base::StringPiece& data,
+ base::StringPiece data,
const DnsRecordParser& parser) {
if (!HasValidSize(data, kType))
return nullptr;
@@ -146,7 +146,7 @@
// static
std::unique_ptr<CnameRecordRdata> CnameRecordRdata::Create(
- const base::StringPiece& data,
+ base::StringPiece data,
const DnsRecordParser& parser) {
auto rdata = base::WrapUnique(new CnameRecordRdata());
@@ -173,7 +173,7 @@
// static
std::unique_ptr<PtrRecordRdata> PtrRecordRdata::Create(
- const base::StringPiece& data,
+ base::StringPiece data,
const DnsRecordParser& parser) {
auto rdata = base::WrapUnique(new PtrRecordRdata());
@@ -199,7 +199,7 @@
// static
std::unique_ptr<TxtRecordRdata> TxtRecordRdata::Create(
- const base::StringPiece& data,
+ base::StringPiece data,
const DnsRecordParser& parser) {
auto rdata = base::WrapUnique(new TxtRecordRdata());
@@ -234,7 +234,7 @@
// static
std::unique_ptr<NsecRecordRdata> NsecRecordRdata::Create(
- const base::StringPiece& data,
+ base::StringPiece data,
const DnsRecordParser& parser) {
auto rdata = base::WrapUnique(new NsecRecordRdata());
diff --git a/net/dns/record_rdata.h b/net/dns/record_rdata.h
index a1a522d..5eb65f1 100644
--- a/net/dns/record_rdata.h
+++ b/net/dns/record_rdata.h
@@ -35,7 +35,7 @@
// Return true if `data` represents RDATA in the wire format with a valid size
// for the give `type`. Always returns true for unrecognized `type`s as the
// size is never known to be invalid.
- static bool HasValidSize(const base::StringPiece& data, uint16_t type);
+ static bool HasValidSize(base::StringPiece data, uint16_t type);
virtual bool IsEqual(const RecordRdata* other) const = 0;
virtual uint16_t Type() const = 0;
@@ -54,7 +54,7 @@
SrvRecordRdata& operator=(const SrvRecordRdata&) = delete;
~SrvRecordRdata() override;
- static std::unique_ptr<SrvRecordRdata> Create(const base::StringPiece& data,
+ static std::unique_ptr<SrvRecordRdata> Create(base::StringPiece data,
const DnsRecordParser& parser);
bool IsEqual(const RecordRdata* other) const override;
@@ -86,7 +86,7 @@
ARecordRdata& operator=(const ARecordRdata&) = delete;
~ARecordRdata() override;
- static std::unique_ptr<ARecordRdata> Create(const base::StringPiece& data,
+ static std::unique_ptr<ARecordRdata> Create(base::StringPiece data,
const DnsRecordParser& parser);
bool IsEqual(const RecordRdata* other) const override;
uint16_t Type() const override;
@@ -109,7 +109,7 @@
AAAARecordRdata& operator=(const AAAARecordRdata&) = delete;
~AAAARecordRdata() override;
- static std::unique_ptr<AAAARecordRdata> Create(const base::StringPiece& data,
+ static std::unique_ptr<AAAARecordRdata> Create(base::StringPiece data,
const DnsRecordParser& parser);
bool IsEqual(const RecordRdata* other) const override;
uint16_t Type() const override;
@@ -133,7 +133,7 @@
~CnameRecordRdata() override;
static std::unique_ptr<CnameRecordRdata> Create(
- const base::StringPiece& data,
+ base::StringPiece data,
const DnsRecordParser& parser);
bool IsEqual(const RecordRdata* other) const override;
uint16_t Type() const override;
@@ -156,7 +156,7 @@
PtrRecordRdata& operator=(const PtrRecordRdata&) = delete;
~PtrRecordRdata() override;
- static std::unique_ptr<PtrRecordRdata> Create(const base::StringPiece& data,
+ static std::unique_ptr<PtrRecordRdata> Create(base::StringPiece data,
const DnsRecordParser& parser);
bool IsEqual(const RecordRdata* other) const override;
uint16_t Type() const override;
@@ -180,7 +180,7 @@
TxtRecordRdata& operator=(const TxtRecordRdata&) = delete;
~TxtRecordRdata() override;
- static std::unique_ptr<TxtRecordRdata> Create(const base::StringPiece& data,
+ static std::unique_ptr<TxtRecordRdata> Create(base::StringPiece data,
const DnsRecordParser& parser);
bool IsEqual(const RecordRdata* other) const override;
uint16_t Type() const override;
@@ -205,7 +205,7 @@
NsecRecordRdata& operator=(const NsecRecordRdata&) = delete;
~NsecRecordRdata() override;
- static std::unique_ptr<NsecRecordRdata> Create(const base::StringPiece& data,
+ static std::unique_ptr<NsecRecordRdata> Create(base::StringPiece data,
const DnsRecordParser& parser);
bool IsEqual(const RecordRdata* other) const override;
uint16_t Type() const override;
diff --git a/net/http/http_request_headers.cc b/net/http/http_request_headers.cc
index 13f417b..0619a87 100644
--- a/net/http/http_request_headers.cc
+++ b/net/http/http_request_headers.cc
@@ -73,8 +73,8 @@
HttpRequestHeaders::HeaderKeyValuePair::HeaderKeyValuePair() = default;
HttpRequestHeaders::HeaderKeyValuePair::HeaderKeyValuePair(
- const base::StringPiece& key,
- const base::StringPiece& value)
+ base::StringPiece key,
+ base::StringPiece value)
: key(key.data(), key.size()), value(value.data(), value.size()) {}
HttpRequestHeaders::Iterator::Iterator(const HttpRequestHeaders& headers)
@@ -106,7 +106,7 @@
HttpRequestHeaders& HttpRequestHeaders::operator=(HttpRequestHeaders&& other) =
default;
-bool HttpRequestHeaders::GetHeader(const base::StringPiece& key,
+bool HttpRequestHeaders::GetHeader(base::StringPiece key,
std::string* out) const {
auto it = FindHeader(key);
if (it == headers_.end())
@@ -119,8 +119,8 @@
headers_.clear();
}
-void HttpRequestHeaders::SetHeader(const base::StringPiece& key,
- const base::StringPiece& value) {
+void HttpRequestHeaders::SetHeader(base::StringPiece key,
+ base::StringPiece value) {
// Invalid header names or values could mean clients can attach
// browser-internal headers.
CHECK(HttpUtil::IsValidHeaderName(key)) << key;
@@ -128,8 +128,8 @@
SetHeaderInternal(key, value);
}
-void HttpRequestHeaders::SetHeaderIfMissing(const base::StringPiece& key,
- const base::StringPiece& value) {
+void HttpRequestHeaders::SetHeaderIfMissing(base::StringPiece key,
+ base::StringPiece value) {
// Invalid header names or values could mean clients can attach
// browser-internal headers.
CHECK(HttpUtil::IsValidHeaderName(key));
@@ -139,14 +139,13 @@
headers_.push_back(HeaderKeyValuePair(key, value));
}
-void HttpRequestHeaders::RemoveHeader(const base::StringPiece& key) {
+void HttpRequestHeaders::RemoveHeader(base::StringPiece key) {
auto it = FindHeader(key);
if (it != headers_.end())
headers_.erase(it);
}
-void HttpRequestHeaders::AddHeaderFromString(
- const base::StringPiece& header_line) {
+void HttpRequestHeaders::AddHeaderFromString(base::StringPiece header_line) {
DCHECK_EQ(std::string::npos, header_line.find("\r\n"))
<< "\"" << header_line << "\" contains CRLF.";
@@ -185,9 +184,8 @@
}
}
-void HttpRequestHeaders::AddHeadersFromString(
- const base::StringPiece& headers) {
- for (const base::StringPiece& header : base::SplitStringPieceUsingSubstr(
+void HttpRequestHeaders::AddHeadersFromString(base::StringPiece headers) {
+ for (base::StringPiece header : base::SplitStringPieceUsingSubstr(
headers, "\r\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
AddHeaderFromString(header);
}
@@ -270,7 +268,7 @@
}
HttpRequestHeaders::HeaderVector::iterator HttpRequestHeaders::FindHeader(
- const base::StringPiece& key) {
+ base::StringPiece key) {
for (auto it = headers_.begin(); it != headers_.end(); ++it) {
if (base::EqualsCaseInsensitiveASCII(key, it->key))
return it;
@@ -280,7 +278,7 @@
}
HttpRequestHeaders::HeaderVector::const_iterator HttpRequestHeaders::FindHeader(
- const base::StringPiece& key) const {
+ base::StringPiece key) const {
for (auto it = headers_.begin(); it != headers_.end(); ++it) {
if (base::EqualsCaseInsensitiveASCII(key, it->key))
return it;
@@ -289,8 +287,8 @@
return headers_.end();
}
-void HttpRequestHeaders::SetHeaderInternal(const base::StringPiece& key,
- const base::StringPiece& value) {
+void HttpRequestHeaders::SetHeaderInternal(base::StringPiece key,
+ base::StringPiece value) {
auto it = FindHeader(key);
if (it != headers_.end())
it->value.assign(value.data(), value.size());
diff --git a/net/http/http_request_headers.h b/net/http/http_request_headers.h
index bf07c8d..4ce46f9 100644
--- a/net/http/http_request_headers.h
+++ b/net/http/http_request_headers.h
@@ -32,8 +32,7 @@
public:
struct NET_EXPORT HeaderKeyValuePair {
HeaderKeyValuePair();
- HeaderKeyValuePair(const base::StringPiece& key,
- const base::StringPiece& value);
+ HeaderKeyValuePair(base::StringPiece key, base::StringPiece value);
std::string key;
std::string value;
@@ -111,13 +110,13 @@
bool IsEmpty() const { return headers_.empty(); }
- bool HasHeader(const base::StringPiece& key) const {
+ bool HasHeader(base::StringPiece key) const {
return FindHeader(key) != headers_.end();
}
// Gets the first header that matches |key|. If found, returns true and
// writes the value to |out|.
- bool GetHeader(const base::StringPiece& key, std::string* out) const;
+ bool GetHeader(base::StringPiece key, std::string* out) const;
// Clears all the headers.
void Clear();
@@ -127,11 +126,11 @@
// in the vector remains the same. When comparing |key|, case is ignored.
// The caller must ensure that |key| passes HttpUtil::IsValidHeaderName() and
// |value| passes HttpUtil::IsValidHeaderValue().
- void SetHeader(const base::StringPiece& key, const base::StringPiece& value);
+ void SetHeader(base::StringPiece key, base::StringPiece value);
// Does the same as above but without internal DCHECKs for validations.
- void SetHeaderWithoutCheckForTesting(const base::StringPiece& key,
- const base::StringPiece& value) {
+ void SetHeaderWithoutCheckForTesting(base::StringPiece key,
+ base::StringPiece value) {
SetHeaderInternal(key, value);
}
@@ -141,11 +140,10 @@
//
// The caller must ensure that |key| passes HttpUtil::IsValidHeaderName() and
// |value| passes HttpUtil::IsValidHeaderValue().
- void SetHeaderIfMissing(const base::StringPiece& key,
- const base::StringPiece& value);
+ void SetHeaderIfMissing(base::StringPiece key, base::StringPiece value);
// Removes the first header that matches (case insensitive) |key|.
- void RemoveHeader(const base::StringPiece& key);
+ void RemoveHeader(base::StringPiece key);
// Parses the header from a string and calls SetHeader() with it. This string
// should not contain any CRLF. As per RFC7230 Section 3.2, the format is:
@@ -163,12 +161,12 @@
//
// AddHeaderFromString() will trim any LWS surrounding the
// field-content.
- void AddHeaderFromString(const base::StringPiece& header_line);
+ void AddHeaderFromString(base::StringPiece header_line);
// Same thing as AddHeaderFromString() except that |headers| is a "\r\n"
// delimited string of header lines. It will split up the string by "\r\n"
// and call AddHeaderFromString() on each.
- void AddHeadersFromString(const base::StringPiece& headers);
+ void AddHeadersFromString(base::StringPiece headers);
// Calls SetHeader() on each header from |other|, maintaining order.
void MergeFrom(const HttpRequestHeaders& other);
@@ -199,11 +197,10 @@
bool enable_brotli);
private:
- HeaderVector::iterator FindHeader(const base::StringPiece& key);
- HeaderVector::const_iterator FindHeader(const base::StringPiece& key) const;
+ HeaderVector::iterator FindHeader(base::StringPiece key);
+ HeaderVector::const_iterator FindHeader(base::StringPiece key) const;
- void SetHeaderInternal(const base::StringPiece& key,
- const base::StringPiece& value);
+ void SetHeaderInternal(base::StringPiece key, base::StringPiece value);
HeaderVector headers_;
diff --git a/net/http/http_stream_parser.cc b/net/http/http_stream_parser.cc
index c1cb5f2..268d4f2 100644
--- a/net/http/http_stream_parser.cc
+++ b/net/http/http_stream_parser.cc
@@ -1149,7 +1149,7 @@
stream_socket_->GetSSLCertRequestInfo(cert_request_info);
}
-int HttpStreamParser::EncodeChunk(const base::StringPiece& payload,
+int HttpStreamParser::EncodeChunk(base::StringPiece payload,
char* output,
size_t output_size) {
if (output_size < payload.size() + kChunkHeaderFooterSize)
diff --git a/net/http/http_stream_parser.h b/net/http/http_stream_parser.h
index 6b1801d2..c95be8f 100644
--- a/net/http/http_stream_parser.h
+++ b/net/http/http_stream_parser.h
@@ -122,7 +122,7 @@
//
// The output will look like: "HEX\r\n[payload]\r\n"
// where HEX is a length in hexdecimal (without the "0x" prefix).
- static int EncodeChunk(const base::StringPiece& payload,
+ static int EncodeChunk(base::StringPiece payload,
char* output,
size_t output_size);
diff --git a/net/http/http_util.cc b/net/http/http_util.cc
index 3aad15ad..21318e1 100644
--- a/net/http/http_util.cc
+++ b/net/http/http_util.cc
@@ -438,7 +438,7 @@
}
// static
-base::StringPiece HttpUtil::TrimLWS(const base::StringPiece& string) {
+base::StringPiece HttpUtil::TrimLWS(base::StringPiece string) {
const char* begin = string.data();
const char* end = string.data() + string.size();
TrimLWSImplementation(&begin, &end);
diff --git a/net/http/http_util.h b/net/http/http_util.h
index 11cae3a8..fc7e693 100644
--- a/net/http/http_util.h
+++ b/net/http/http_util.h
@@ -122,7 +122,7 @@
// Trim HTTP_LWS chars from the beginning and end of the string.
static void TrimLWS(std::string::const_iterator* begin,
std::string::const_iterator* end);
- static base::StringPiece TrimLWS(const base::StringPiece& string);
+ static base::StringPiece TrimLWS(base::StringPiece string);
// Whether the character is a valid |tchar| as defined in RFC 7230 Sec 3.2.6.
static bool IsTokenChar(char c);
diff --git a/net/http/structured_headers.h b/net/http/structured_headers.h
index 6f8289be..7a3dda9 100644
--- a/net/http/structured_headers.h
+++ b/net/http/structured_headers.h
@@ -47,8 +47,7 @@
return quiche::structured_headers::ParseList(
base::StringPieceToStringView(str));
}
-inline absl::optional<Dictionary> ParseDictionary(
- const base::StringPiece& str) {
+inline absl::optional<Dictionary> ParseDictionary(base::StringPiece str) {
return quiche::structured_headers::ParseDictionary(
base::StringPieceToStringView(str));
}
diff --git a/net/server/http_server_request_info.cc b/net/server/http_server_request_info.cc
index 3bbdba0..2b82826 100644
--- a/net/server/http_server_request_info.cc
+++ b/net/server/http_server_request_info.cc
@@ -32,7 +32,7 @@
DCHECK_EQ(base::ToLowerASCII(header_value), header_value);
std::string complete_value = base::ToLowerASCII(GetHeaderValue(header_name));
- for (const base::StringPiece& cur :
+ for (base::StringPiece cur :
base::SplitStringPiece(complete_value, ",", base::KEEP_WHITESPACE,
base::SPLIT_WANT_NONEMPTY)) {
if (base::TrimString(cur, " \t", base::TRIM_ALL) == header_value)
diff --git a/net/server/web_socket_encoder.cc b/net/server/web_socket_encoder.cc
index ed8179d..812ab737 100644
--- a/net/server/web_socket_encoder.cc
+++ b/net/server/web_socket_encoder.cc
@@ -41,7 +41,7 @@
const size_t kEightBytePayloadLengthField = 127;
const size_t kMaskingKeyWidthInBytes = 4;
-WebSocket::ParseResult DecodeFrameHybi17(const base::StringPiece& frame,
+WebSocket::ParseResult DecodeFrameHybi17(base::StringPiece frame,
bool client_frame,
int* bytes_consumed,
std::string* output,
@@ -293,10 +293,9 @@
WebSocketEncoder::~WebSocketEncoder() = default;
-WebSocket::ParseResult WebSocketEncoder::DecodeFrame(
- const base::StringPiece& frame,
- int* bytes_consumed,
- std::string* output) {
+WebSocket::ParseResult WebSocketEncoder::DecodeFrame(base::StringPiece frame,
+ int* bytes_consumed,
+ std::string* output) {
bool compressed;
std::string current_output;
WebSocket::ParseResult result = DecodeFrameHybi17(
diff --git a/net/server/web_socket_encoder.h b/net/server/web_socket_encoder.h
index f385cbd5..1604a82 100644
--- a/net/server/web_socket_encoder.h
+++ b/net/server/web_socket_encoder.h
@@ -38,7 +38,7 @@
static std::unique_ptr<WebSocketEncoder> CreateClient(
const std::string& response_extensions);
- WebSocket::ParseResult DecodeFrame(const base::StringPiece& frame,
+ WebSocket::ParseResult DecodeFrame(base::StringPiece frame,
int* bytes_consumed,
std::string* output);
void EncodeTextFrame(base::StringPiece frame,
diff --git a/net/socket/fuzzed_socket_factory.cc b/net/socket/fuzzed_socket_factory.cc
index 914d48b0c..0862a934 100644
--- a/net/socket/fuzzed_socket_factory.cc
+++ b/net/socket/fuzzed_socket_factory.cc
@@ -85,9 +85,9 @@
void ApplySocketTag(const net::SocketTag& tag) override {}
// SSLSocket implementation:
- int ExportKeyingMaterial(const base::StringPiece& label,
+ int ExportKeyingMaterial(base::StringPiece label,
bool has_context,
- const base::StringPiece& context,
+ base::StringPiece context,
unsigned char* out,
unsigned int outlen) override {
NOTREACHED();
diff --git a/net/socket/socket_test_util.cc b/net/socket/socket_test_util.cc
index 1e30534..4fbbf88 100644
--- a/net/socket/socket_test_util.cc
+++ b/net/socket/socket_test_util.cc
@@ -1455,9 +1455,9 @@
}
}
-int MockSSLClientSocket::ExportKeyingMaterial(const base::StringPiece& label,
+int MockSSLClientSocket::ExportKeyingMaterial(base::StringPiece label,
bool has_context,
- const base::StringPiece& context,
+ base::StringPiece context,
unsigned char* out,
unsigned int outlen) {
memset(out, 'A', outlen);
diff --git a/net/socket/socket_test_util.h b/net/socket/socket_test_util.h
index 227e6d4..1b45d9a 100644
--- a/net/socket/socket_test_util.h
+++ b/net/socket/socket_test_util.h
@@ -912,9 +912,9 @@
int SetSendBufferSize(int32_t size) override;
// SSLSocket implementation.
- int ExportKeyingMaterial(const base::StringPiece& label,
+ int ExportKeyingMaterial(base::StringPiece label,
bool has_context,
- const base::StringPiece& context,
+ base::StringPiece context,
unsigned char* out,
unsigned int outlen) override;
diff --git a/net/socket/ssl_client_socket_impl.cc b/net/socket/ssl_client_socket_impl.cc
index c9769f8..93e42ef 100644
--- a/net/socket/ssl_client_socket_impl.cc
+++ b/net/socket/ssl_client_socket_impl.cc
@@ -408,9 +408,9 @@
return std::vector<uint8_t>(retry_configs, retry_configs + retry_configs_len);
}
-int SSLClientSocketImpl::ExportKeyingMaterial(const base::StringPiece& label,
+int SSLClientSocketImpl::ExportKeyingMaterial(base::StringPiece label,
bool has_context,
- const base::StringPiece& context,
+ base::StringPiece context,
unsigned char* out,
unsigned int outlen) {
if (!IsConnected())
diff --git a/net/socket/ssl_client_socket_impl.h b/net/socket/ssl_client_socket_impl.h
index 9f38ffa..f3f9a76 100644
--- a/net/socket/ssl_client_socket_impl.h
+++ b/net/socket/ssl_client_socket_impl.h
@@ -76,9 +76,9 @@
std::vector<uint8_t> GetECHRetryConfigs() override;
// SSLSocket implementation.
- int ExportKeyingMaterial(const base::StringPiece& label,
+ int ExportKeyingMaterial(base::StringPiece label,
bool has_context,
- const base::StringPiece& context,
+ base::StringPiece context,
unsigned char* out,
unsigned int outlen) override;
diff --git a/net/socket/ssl_server_socket_impl.cc b/net/socket/ssl_server_socket_impl.cc
index 052de0882..5bfd2a8 100644
--- a/net/socket/ssl_server_socket_impl.cc
+++ b/net/socket/ssl_server_socket_impl.cc
@@ -60,9 +60,9 @@
int Handshake(CompletionOnceCallback callback) override;
// SSLSocket interface.
- int ExportKeyingMaterial(const base::StringPiece& label,
+ int ExportKeyingMaterial(base::StringPiece label,
bool has_context,
- const base::StringPiece& context,
+ base::StringPiece context,
unsigned char* out,
unsigned int outlen) override;
@@ -399,9 +399,9 @@
}
int SSLServerContextImpl::SocketImpl::ExportKeyingMaterial(
- const base::StringPiece& label,
+ base::StringPiece label,
bool has_context,
- const base::StringPiece& context,
+ base::StringPiece context,
unsigned char* out,
unsigned int outlen) {
if (!IsConnected())
diff --git a/net/socket/ssl_server_socket_unittest.cc b/net/socket/ssl_server_socket_unittest.cc
index 4d903ea..932b930 100644
--- a/net/socket/ssl_server_socket_unittest.cc
+++ b/net/socket/ssl_server_socket_unittest.cc
@@ -474,8 +474,7 @@
server_ssl_config_.client_cert_verifier = client_cert_verifier_.get();
}
- std::unique_ptr<crypto::RSAPrivateKey> ReadTestKey(
- const base::StringPiece& name) {
+ std::unique_ptr<crypto::RSAPrivateKey> ReadTestKey(base::StringPiece name) {
base::FilePath certs_dir(GetTestCertsDirectory());
base::FilePath key_path = certs_dir.AppendASCII(name);
std::string key_string;
diff --git a/net/socket/ssl_socket.h b/net/socket/ssl_socket.h
index 38f429b..7bea422 100644
--- a/net/socket/ssl_socket.h
+++ b/net/socket/ssl_socket.h
@@ -22,9 +22,9 @@
// RFC and |context| is ignored. The call will fail with an error if
// the socket is not connected or the SSL implementation does not
// support the operation.
- virtual int ExportKeyingMaterial(const base::StringPiece& label,
+ virtual int ExportKeyingMaterial(base::StringPiece label,
bool has_context,
- const base::StringPiece& context,
+ base::StringPiece context,
unsigned char* out,
unsigned int outlen) = 0;
};
diff --git a/net/test/embedded_test_server/http_request.cc b/net/test/embedded_test_server/http_request.cc
index b627b2de..b9b96cd 100644
--- a/net/test/embedded_test_server/http_request.cc
+++ b/net/test/embedded_test_server/http_request.cc
@@ -46,7 +46,7 @@
HttpRequestParser::~HttpRequestParser() = default;
-void HttpRequestParser::ProcessChunk(const base::StringPiece& data) {
+void HttpRequestParser::ProcessChunk(base::StringPiece data) {
buffer_.append(data.data(), data.size());
DCHECK_LE(buffer_.size() + data.size(), kRequestSizeLimit) <<
"The HTTP request is too large.";
diff --git a/net/test/embedded_test_server/http_request.h b/net/test/embedded_test_server/http_request.h
index 4dcab26..d356fe5 100644
--- a/net/test/embedded_test_server/http_request.h
+++ b/net/test/embedded_test_server/http_request.h
@@ -104,7 +104,7 @@
~HttpRequestParser();
// Adds chunk of data into the internal buffer.
- void ProcessChunk(const base::StringPiece& data);
+ void ProcessChunk(base::StringPiece data);
// Parses the http request (including data - if provided).
// If returns ACCEPTED, then it means that the whole request has been found
diff --git a/net/tools/transport_security_state_generator/input_file_parsers.cc b/net/tools/transport_security_state_generator/input_file_parsers.cc
index c9d37387d..d428662 100644
--- a/net/tools/transport_security_state_generator/input_file_parsers.cc
+++ b/net/tools/transport_security_state_generator/input_file_parsers.cc
@@ -97,7 +97,7 @@
}
for (size_t i = 0; i < words.size(); ++i) {
- const base::StringPiece& word = words[i];
+ base::StringPiece word = words[i];
if (word == "Class" && (i + 1) < words.size()) {
std::string class_name = base::StrCat({word, words[i + 1]});
@@ -200,7 +200,7 @@
bssl::UniquePtr<X509> certificate;
SPKIHash hash;
- for (const base::StringPiece& line : SplitStringPiece(
+ for (base::StringPiece line : SplitStringPiece(
certs_input, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL)) {
if (!line.empty() && line[0] == '#') {
continue;
diff --git a/net/websockets/websocket_basic_handshake_stream.cc b/net/websockets/websocket_basic_handshake_stream.cc
index 387ac70..5ad9818 100644
--- a/net/websockets/websocket_basic_handshake_stream.cc
+++ b/net/websockets/websocket_basic_handshake_stream.cc
@@ -78,7 +78,7 @@
}
GetHeaderResult GetSingleHeaderValue(const HttpResponseHeaders* headers,
- const base::StringPiece& name,
+ base::StringPiece name,
std::string* value) {
size_t iter = 0;
size_t num_values = 0;
diff --git a/net/websockets/websocket_channel_test.cc b/net/websockets/websocket_channel_test.cc
index cb8a8f5..38c961b 100644
--- a/net/websockets/websocket_channel_test.cc
+++ b/net/websockets/websocket_channel_test.cc
@@ -769,14 +769,14 @@
std::unique_ptr<WebSocketStream::ConnectDelegate> connect_delegate;
};
-std::vector<char> AsVector(const base::StringPiece& s) {
+std::vector<char> AsVector(base::StringPiece s) {
return std::vector<char>(s.begin(), s.end());
}
// Converts a base::StringPiece to a IOBuffer. For test purposes, it is
// convenient to be able to specify data as a string, but the
// WebSocketEventInterface requires the IOBuffer type.
-scoped_refptr<IOBuffer> AsIOBuffer(const base::StringPiece& s) {
+scoped_refptr<IOBuffer> AsIOBuffer(base::StringPiece s) {
auto buffer = base::MakeRefCounted<IOBuffer>(s.size());
std::copy(s.begin(), s.end(), buffer->data());
return buffer;
diff --git a/net/websockets/websocket_end_to_end_test.cc b/net/websockets/websocket_end_to_end_test.cc
index d4ad872d..908accf6 100644
--- a/net/websockets/websocket_end_to_end_test.cc
+++ b/net/websockets/websocket_end_to_end_test.cc
@@ -82,7 +82,7 @@
static const char kEchoServer[] = "echo-with-no-extension";
// Simplify changing URL schemes.
-GURL ReplaceUrlScheme(const GURL& in_url, const base::StringPiece& scheme) {
+GURL ReplaceUrlScheme(const GURL& in_url, base::StringPiece scheme) {
GURL::Replacements replacements;
replacements.SetSchemeStr(scheme);
return in_url.ReplaceComponents(replacements);
