Replace QuicheStringPiece with absl::string_view
PiperOrigin-RevId: 336003023
Change-Id: I317fcb072dad195e937af96e12b175e11ab44170
diff --git a/quic/core/chlo_extractor.cc b/quic/core/chlo_extractor.cc
index 1605b26..53c3246 100644
--- a/quic/core/chlo_extractor.cc
+++ b/quic/core/chlo_extractor.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/chlo_extractor.h"
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
@@ -14,7 +15,6 @@
#include "net/third_party/quiche/src/quic/core/frames/quic_ack_frequency_frame.h"
#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/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
@@ -39,10 +39,9 @@
const QuicVersionNegotiationPacket& /*packet*/) override {}
void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
QuicConnectionId /*new_connection_id*/,
- quiche::QuicheStringPiece /*retry_token*/,
- quiche::QuicheStringPiece /*retry_integrity_tag*/,
- quiche::QuicheStringPiece /*retry_without_tag*/) override {
- }
+ absl::string_view /*retry_token*/,
+ absl::string_view /*retry_integrity_tag*/,
+ absl::string_view /*retry_without_tag*/) override {}
bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override;
bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
void OnDecryptedPacket(EncryptionLevel /*level*/) override {}
@@ -89,7 +88,7 @@
void OnHandshakeMessage(const CryptoHandshakeMessage& message) override;
// Shared implementation between OnStreamFrame and OnCryptoFrame.
- bool OnHandshakeData(quiche::QuicheStringPiece data);
+ bool OnHandshakeData(absl::string_view data);
bool found_chlo() { return found_chlo_; }
bool chlo_contains_tags() { return chlo_contains_tags_; }
@@ -153,7 +152,7 @@
// CHLO will be sent in CRYPTO frames in v47 and above.
return false;
}
- quiche::QuicheStringPiece data(frame.data_buffer, frame.data_length);
+ absl::string_view data(frame.data_buffer, frame.data_length);
if (QuicUtils::IsCryptoStreamId(framer_->transport_version(),
frame.stream_id) &&
frame.offset == 0 && quiche::QuicheTextUtils::StartsWith(data, "CHLO")) {
@@ -167,14 +166,14 @@
// CHLO will be in stream frames before v47.
return false;
}
- quiche::QuicheStringPiece data(frame.data_buffer, frame.data_length);
+ absl::string_view data(frame.data_buffer, frame.data_length);
if (frame.offset == 0 && quiche::QuicheTextUtils::StartsWith(data, "CHLO")) {
return OnHandshakeData(data);
}
return true;
}
-bool ChloFramerVisitor::OnHandshakeData(quiche::QuicheStringPiece data) {
+bool ChloFramerVisitor::OnHandshakeData(absl::string_view data) {
CryptoFramer crypto_framer;
crypto_framer.set_visitor(this);
if (!crypto_framer.ProcessInput(data)) {
diff --git a/quic/core/chlo_extractor_test.cc b/quic/core/chlo_extractor_test.cc
index 1b6a616..3c968be 100644
--- a/quic/core/chlo_extractor_test.cc
+++ b/quic/core/chlo_extractor_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#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_test.h"
@@ -15,7 +16,6 @@
#include "net/third_party/quiche/src/quic/test_tools/first_flight.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
namespace test {
@@ -33,7 +33,7 @@
version_ = version;
connection_id_ = connection_id;
chlo_ = chlo.DebugString();
- quiche::QuicheStringPiece alpn_value;
+ absl::string_view alpn_value;
if (chlo.GetStringPiece(kALPN, &alpn_value)) {
alpn_ = std::string(alpn_value);
}
@@ -55,7 +55,7 @@
public:
ChloExtractorTest() : version_(GetParam()) {}
- void MakePacket(quiche::QuicheStringPiece data,
+ void MakePacket(absl::string_view data,
bool munge_offset,
bool munge_stream_id) {
QuicPacketHeader header;
diff --git a/quic/core/quic_bandwidth.cc b/quic/core/quic_bandwidth.cc
index ad2c032..144a176 100644
--- a/quic/core/quic_bandwidth.cc
+++ b/quic/core/quic_bandwidth.cc
@@ -7,8 +7,8 @@
#include <cinttypes>
#include <string>
+#include "absl/strings/string_view.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 {
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 0d1cd27..5ea6b24 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -10,6 +10,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
@@ -23,7 +24,6 @@
#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_uint128.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -411,7 +411,7 @@
const CryptoHandshakeMessage& peer_hello,
HelloType /*hello_type*/,
std::string* error_details) {
- quiche::QuicheStringPiece address;
+ absl::string_view address;
if (!peer_hello.GetStringPiece(tag_, &address)) {
if (presence_ == PRESENCE_REQUIRED) {
*error_details = "Missing " + QuicTagToString(tag_);
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index a2f32b6..00bfa6b 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -15,6 +15,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
@@ -41,7 +42,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_string_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
@@ -887,12 +887,11 @@
}
// Handles retry for client connection.
-void QuicConnection::OnRetryPacket(
- QuicConnectionId original_connection_id,
- QuicConnectionId new_connection_id,
- quiche::QuicheStringPiece retry_token,
- quiche::QuicheStringPiece retry_integrity_tag,
- quiche::QuicheStringPiece retry_without_tag) {
+void QuicConnection::OnRetryPacket(QuicConnectionId original_connection_id,
+ QuicConnectionId new_connection_id,
+ absl::string_view retry_token,
+ absl::string_view retry_integrity_tag,
+ absl::string_view retry_without_tag) {
DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
if (version().HasRetryIntegrityTag()) {
if (!CryptoUtils::ValidateRetryIntegrityTag(
@@ -1691,7 +1690,7 @@
}
MaybeUpdateAckTimeout();
visitor_->OnMessageReceived(
- quiche::QuicheStringPiece(frame.data, frame.message_length));
+ absl::string_view(frame.data, frame.message_length));
return connected_;
}
@@ -2197,8 +2196,8 @@
}
QUIC_DVLOG(2) << ENDPOINT << "Received encrypted " << packet.length()
<< " bytes:" << std::endl
- << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
- packet.data(), packet.length()));
+ << quiche::QuicheTextUtils::HexDump(
+ absl::string_view(packet.data(), packet.length()));
QUIC_BUG_IF(current_packet_data_ != nullptr)
<< "ProcessUdpPacket must not be called while processing a packet.";
if (debug_visitor_ != nullptr) {
@@ -2718,7 +2717,7 @@
QUIC_DVLOG(2) << ENDPOINT << packet->encryption_level << " packet number "
<< packet_number << " of length " << encrypted_length << ": "
<< std::endl
- << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
+ << quiche::QuicheTextUtils::HexDump(absl::string_view(
packet->encrypted_buffer, encrypted_length));
// Measure the RTT from before the write begins to avoid underestimating the
@@ -2817,8 +2816,8 @@
QuicPacketLength encapsulated_length =
QuicLegacyVersionEncapsulator::Encapsulate(
legacy_version_encapsulation_sni_,
- quiche::QuicheStringPiece(packet->encrypted_buffer,
- packet->encrypted_length),
+ absl::string_view(packet->encrypted_buffer,
+ packet->encrypted_length),
server_connection_id_, framer_.creation_time(),
GetLimitedMaxPacketSize(long_term_mtu_),
const_cast<char*>(packet->encrypted_buffer));
@@ -2831,7 +2830,7 @@
<< "Successfully performed Legacy Version Encapsulation on "
<< packet->encryption_level << " packet number " << packet_number
<< " of length " << encrypted_length << ": " << std::endl
- << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
+ << quiche::QuicheTextUtils::HexDump(absl::string_view(
packet->encrypted_buffer, encrypted_length));
} else {
QUIC_BUG << ENDPOINT
@@ -4134,9 +4133,9 @@
QUIC_DVLOG(2) << ENDPOINT
<< "Sending path probe packet for server connection ID "
<< server_connection_id_ << std::endl
- << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
- probing_packet->encrypted_buffer,
- probing_packet->encrypted_length));
+ << quiche::QuicheTextUtils::HexDump(
+ absl::string_view(probing_packet->encrypted_buffer,
+ probing_packet->encrypted_length));
WriteResult result = probing_writer->WritePacket(
probing_packet->encrypted_buffer, probing_packet->encrypted_length,
self_address().host(), peer_address, per_packet_options_);
@@ -4268,11 +4267,11 @@
return uber_received_packet_manager_.IsAckFrameUpdated();
}
-quiche::QuicheStringPiece QuicConnection::GetCurrentPacket() {
+absl::string_view QuicConnection::GetCurrentPacket() {
if (current_packet_data_ == nullptr) {
- return quiche::QuicheStringPiece();
+ return absl::string_view();
}
- return quiche::QuicheStringPiece(current_packet_data_, last_size_);
+ return absl::string_view(current_packet_data_, last_size_);
}
bool QuicConnection::MaybeConsiderAsMemoryCorruption(
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 06488e5..3c37fa7 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -11,6 +11,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/congestion_control/loss_detection_interface.h"
#include "net/third_party/quiche/src/quic/core/congestion_control/send_algorithm_interface.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
@@ -42,7 +43,6 @@
#include "net/third_party/quiche/src/quic/test_tools/simple_session_notifier.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
using testing::_;
using testing::AnyNumber;
@@ -116,9 +116,7 @@
~StrictTaggingDecrypter() override {}
// TaggingQuicDecrypter
- uint8_t GetTag(quiche::QuicheStringPiece /*ciphertext*/) override {
- return tag_;
- }
+ uint8_t GetTag(absl::string_view /*ciphertext*/) override { return tag_; }
// Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
uint32_t cipher_id() const override { return 0xFFFFFFF1; }
@@ -252,7 +250,7 @@
}
QuicConsumedData SendStreamDataWithString(QuicStreamId id,
- quiche::QuicheStringPiece data,
+ absl::string_view data,
QuicStreamOffset offset,
StreamSendingState state) {
ScopedPacketFlusher flusher(this);
@@ -273,7 +271,7 @@
QuicConsumedData SendApplicationDataAtLevel(EncryptionLevel encryption_level,
QuicStreamId id,
- quiche::QuicheStringPiece data,
+ absl::string_view data,
QuicStreamOffset offset,
StreamSendingState state) {
ScopedPacketFlusher flusher(this);
@@ -310,7 +308,7 @@
// tests for some cases for this stream.
QuicConsumedData SendCryptoStreamData() {
QuicStreamOffset offset = 0;
- quiche::QuicheStringPiece data("chlo");
+ absl::string_view data("chlo");
if (!QuicVersionUsesCryptoFrames(transport_version())) {
return SendCryptoDataWithString(data, offset);
}
@@ -326,12 +324,12 @@
return QuicConsumedData(bytes_written, /*fin_consumed*/ false);
}
- QuicConsumedData SendCryptoDataWithString(quiche::QuicheStringPiece data,
+ QuicConsumedData SendCryptoDataWithString(absl::string_view data,
QuicStreamOffset offset) {
return SendCryptoDataWithString(data, offset, ENCRYPTION_INITIAL);
}
- QuicConsumedData SendCryptoDataWithString(quiche::QuicheStringPiece data,
+ QuicConsumedData SendCryptoDataWithString(absl::string_view data,
QuicStreamOffset offset,
EncryptionLevel encryption_level) {
if (!QuicVersionUsesCryptoFrames(transport_version())) {
@@ -604,9 +602,9 @@
version()),
creator_(QuicConnectionPeer::GetPacketCreator(&connection_)),
manager_(QuicConnectionPeer::GetSentPacketManager(&connection_)),
- frame1_(0, false, 0, quiche::QuicheStringPiece(data1)),
- frame2_(0, false, 3, quiche::QuicheStringPiece(data2)),
- crypto_frame_(ENCRYPTION_INITIAL, 0, quiche::QuicheStringPiece(data1)),
+ frame1_(0, false, 0, absl::string_view(data1)),
+ frame2_(0, false, 3, absl::string_view(data2)),
+ crypto_frame_(ENCRYPTION_INITIAL, 0, absl::string_view(data1)),
packet_number_length_(PACKET_4BYTE_PACKET_NUMBER),
connection_id_included_(CONNECTION_ID_PRESENT),
notifier_(&connection_),
@@ -750,7 +748,7 @@
}
return QuicFrame(QuicStreamFrame(
QuicUtils::GetCryptoStreamId(connection_.transport_version()), false,
- 0u, quiche::QuicheStringPiece()));
+ 0u, absl::string_view()));
}
void ProcessFramePacket(QuicFrame frame) {
@@ -1006,7 +1004,7 @@
}
QuicByteCount SendStreamDataToPeer(QuicStreamId id,
- quiche::QuicheStringPiece data,
+ absl::string_view data,
QuicStreamOffset offset,
StreamSendingState state,
QuicPacketNumber* last_packet) {
@@ -1043,7 +1041,7 @@
void SendPing() { notifier_.WriteOrBufferPing(); }
- MessageStatus SendMessage(quiche::QuicheStringPiece message) {
+ MessageStatus SendMessage(absl::string_view message) {
connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
return connection_.SendMessage(
@@ -3123,7 +3121,7 @@
QuicStreamFrame* frame = writer_->stream_frames()[0].get();
EXPECT_EQ(stream_id, frame->stream_id);
EXPECT_EQ("ABCDEF",
- quiche::QuicheStringPiece(frame->data_buffer, frame->data_length));
+ absl::string_view(frame->data_buffer, frame->data_length));
}
TEST_P(QuicConnectionTest, FramePackingSendvQueued) {
@@ -8254,7 +8252,7 @@
connection_.SetFromConfig(config);
}
std::string message(connection_.GetCurrentLargestMessagePayload() * 2, 'a');
- quiche::QuicheStringPiece message_data(message);
+ absl::string_view message_data(message);
QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
{
QuicConnection::ScopedPacketFlusher flusher(&connection_);
@@ -8267,7 +8265,7 @@
connection_.SendMessage(
1,
MakeSpan(connection_.helper()->GetStreamSendBufferAllocator(),
- quiche::QuicheStringPiece(
+ absl::string_view(
message_data.data(),
connection_.GetCurrentLargestMessagePayload()),
&storage),
@@ -8288,7 +8286,7 @@
connection_.SendMessage(
3,
MakeSpan(connection_.helper()->GetStreamSendBufferAllocator(),
- quiche::QuicheStringPiece(
+ absl::string_view(
message_data.data(),
connection_.GetCurrentLargestMessagePayload() + 1),
&storage),
@@ -10305,7 +10303,7 @@
frames.push_back(QuicFrame(QuicStreamFrame(
QuicUtils::GetFirstBidirectionalStreamId(
connection_.version().transport_version, Perspective::IS_CLIENT),
- false, 0u, quiche::QuicheStringPiece())));
+ false, 0u, absl::string_view())));
QuicAckFrame ack_frame = InitAckFrame(1);
frames.push_back(QuicFrame(&ack_frame));
// Receiving stream frame causes something to send.
@@ -11044,7 +11042,7 @@
frames.push_back(QuicFrame(&ack_frame));
frames.push_back(QuicFrame(QuicStreamFrame(
GetNthClientInitiatedStreamId(0, connection_.transport_version()), true,
- 0u, quiche::QuicheStringPiece())));
+ 0u, absl::string_view())));
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
@@ -11767,7 +11765,7 @@
frames1.push_back(QuicFrame(&crypto_frame_));
QuicFrames frames2;
QuicCryptoFrame crypto_frame(ENCRYPTION_HANDSHAKE, 0,
- quiche::QuicheStringPiece(data1));
+ absl::string_view(data1));
frames2.push_back(QuicFrame(&crypto_frame));
ProcessCoalescedPacket(
{{2, frames1, ENCRYPTION_INITIAL}, {3, frames2, ENCRYPTION_HANDSHAKE}});
@@ -11798,7 +11796,7 @@
QuicFrames frames2;
QuicCryptoFrame crypto_frame(ENCRYPTION_HANDSHAKE, 0,
- quiche::QuicheStringPiece(data1));
+ absl::string_view(data1));
frames2.push_back(QuicFrame(&crypto_frame));
EXPECT_CALL(debug_visitor, OnZeroRttPacketAcked()).Times(0);
EXPECT_CALL(visitor_, OnCryptoFrame(_)).Times(1);
diff --git a/quic/core/quic_crypto_client_handshaker_test.cc b/quic/core/quic_crypto_client_handshaker_test.cc
index 3ea08a5..cfae506 100644
--- a/quic/core/quic_crypto_client_handshaker_test.cc
+++ b/quic/core/quic_crypto_client_handshaker_test.cc
@@ -6,10 +6,10 @@
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/proto/crypto_server_config_proto.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
namespace {
@@ -34,7 +34,7 @@
const uint16_t /*port*/,
const std::string& /*server_config*/,
QuicTransportVersion /*transport_version*/,
- quiche::QuicheStringPiece /*chlo_hash*/,
+ absl::string_view /*chlo_hash*/,
const std::vector<std::string>& /*certs*/,
const std::string& /*cert_sct*/,
const std::string& /*signature*/,
@@ -74,7 +74,7 @@
const std::string& hostname,
const std::string& /*server_config*/,
QuicTransportVersion /*transport_version*/,
- quiche::QuicheStringPiece /*chlo_hash*/,
+ absl::string_view /*chlo_hash*/,
std::unique_ptr<Callback> callback) override {
QuicReferenceCountedPointer<ProofSource::Chain> chain =
GetCertChain(server_address, client_address, hostname);
@@ -99,7 +99,7 @@
const QuicSocketAddress& /*client_address*/,
const std::string& /*hostname*/,
uint16_t /*signature_algorit*/,
- quiche::QuicheStringPiece /*in*/,
+ absl::string_view /*in*/,
std::unique_ptr<SignatureCallback> callback) override {
callback->Run(true, "Dummy signature", /*details=*/nullptr);
}
diff --git a/quic/core/quic_crypto_server_stream.cc b/quic/core/quic_crypto_server_stream.cc
index 5fc6839..e8f99eb 100644
--- a/quic/core/quic_crypto_server_stream.cc
+++ b/quic/core/quic_crypto_server_stream.cc
@@ -7,10 +7,10 @@
#include <memory>
#include <string>
+#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/sha.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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 {
@@ -286,8 +286,8 @@
<< message.DebugString();
if (!QuicVersionUsesCryptoFrames(transport_version())) {
const QuicData& data = message.GetSerialized();
- WriteOrBufferData(quiche::QuicheStringPiece(data.data(), data.length()),
- false, nullptr);
+ WriteOrBufferData(absl::string_view(data.data(), data.length()), false,
+ nullptr);
} else {
SendHandshakeMessage(message);
}
@@ -418,7 +418,7 @@
return;
}
- quiche::QuicheStringPiece user_agent_id;
+ absl::string_view user_agent_id;
message.GetStringPiece(quic::kUAID, &user_agent_id);
if (!session()->user_agent_id().has_value() && !user_agent_id.empty()) {
session()->SetUserAgentId(std::string(user_agent_id));
@@ -430,7 +430,7 @@
if (num_handshake_messages_ == 1) {
// Client attempts zero RTT handshake by sending a non-inchoate CHLO.
- quiche::QuicheStringPiece public_value;
+ absl::string_view public_value;
zero_rtt_attempted_ = message.GetStringPiece(kPUBS, &public_value);
}
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index 9ff7dc0..2831dc0 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -9,6 +9,7 @@
#include <utility>
#include <vector>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/aes_128_gcm_12_encrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
@@ -32,7 +33,6 @@
#include "net/third_party/quiche/src/quic/test_tools/fake_proof_source.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_crypto_server_config_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
class QuicConnection;
@@ -96,7 +96,7 @@
.Times(testing::AnyNumber());
EXPECT_CALL(*server_session_, SelectAlpn(_))
.WillRepeatedly(
- [this](const std::vector<quiche::QuicheStringPiece>& alpns) {
+ [this](const std::vector<absl::string_view>& alpns) {
return std::find(
alpns.cbegin(), alpns.cend(),
AlpnForVersion(server_session_->connection()->version()));
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index ae2f067..6d41f0e 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -6,6 +6,7 @@
#include <string>
+#include "absl/strings/string_view.h"
#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/core/quic_connection.h"
@@ -16,7 +17,6 @@
#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/common/platform/api/quiche_optional.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -108,8 +108,7 @@
EncryptionLevel level) {
struct iovec iov;
while (sequencer->GetReadableRegion(&iov)) {
- quiche::QuicheStringPiece data(static_cast<char*>(iov.iov_base),
- iov.iov_len);
+ absl::string_view data(static_cast<char*>(iov.iov_base), iov.iov_len);
if (!crypto_message_parser()->ProcessInput(data, level)) {
OnUnrecoverableError(crypto_message_parser()->error(),
crypto_message_parser()->error_detail());
@@ -126,8 +125,8 @@
}
}
-bool QuicCryptoStream::ExportKeyingMaterial(quiche::QuicheStringPiece label,
- quiche::QuicheStringPiece context,
+bool QuicCryptoStream::ExportKeyingMaterial(absl::string_view label,
+ absl::string_view context,
size_t result_len,
std::string* result) const {
if (!one_rtt_keys_available()) {
@@ -141,7 +140,7 @@
}
void QuicCryptoStream::WriteCryptoData(EncryptionLevel level,
- quiche::QuicheStringPiece data) {
+ absl::string_view data) {
if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
// The QUIC crypto handshake takes care of setting the appropriate
// encryption level before writing data. Since that is the only handshake
diff --git a/quic/core/quic_crypto_stream.h b/quic/core/quic_crypto_stream.h
index d73d970..21bdde6 100644
--- a/quic/core/quic_crypto_stream.h
+++ b/quic/core/quic_crypto_stream.h
@@ -9,6 +9,7 @@
#include <cstddef>
#include <string>
+#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h"
@@ -17,7 +18,6 @@
#include "net/third_party/quiche/src/quic/core/quic_stream.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -64,14 +64,13 @@
// dependent on |label|, |context|, and the stream's negotiated subkey secret.
// Returns false if the handshake has not been confirmed or the parameters are
// invalid (e.g. |label| contains null bytes); returns true on success.
- bool ExportKeyingMaterial(quiche::QuicheStringPiece label,
- quiche::QuicheStringPiece context,
+ bool ExportKeyingMaterial(absl::string_view label,
+ absl::string_view context,
size_t result_len,
std::string* result) const;
// Writes |data| to the QuicStream at level |level|.
- virtual void WriteCryptoData(EncryptionLevel level,
- quiche::QuicheStringPiece data);
+ virtual void WriteCryptoData(EncryptionLevel level, absl::string_view data);
// Returns the ssl_early_data_reason_t describing why 0-RTT was accepted or
// rejected. Note that the value returned by this function may vary during the
diff --git a/quic/core/quic_data_reader.cc b/quic/core/quic_data_reader.cc
index c82e051..572845d 100644
--- a/quic/core/quic_data_reader.cc
+++ b/quic/core/quic_data_reader.cc
@@ -4,17 +4,17 @@
#include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
-QuicDataReader::QuicDataReader(quiche::QuicheStringPiece data)
+QuicDataReader::QuicDataReader(absl::string_view data)
: quiche::QuicheDataReader(data) {}
QuicDataReader::QuicDataReader(const char* data, const size_t len)
@@ -165,8 +165,7 @@
return false;
}
-bool QuicDataReader::ReadStringPieceVarInt62(
- quiche::QuicheStringPiece* result) {
+bool QuicDataReader::ReadStringPieceVarInt62(absl::string_view* result) {
uint64_t result_length;
if (!ReadVarInt62(&result_length)) {
return false;
diff --git a/quic/core/quic_data_reader.h b/quic/core/quic_data_reader.h
index 13499ea..dd613b0 100644
--- a/quic/core/quic_data_reader.h
+++ b/quic/core/quic_data_reader.h
@@ -8,10 +8,10 @@
#include <cstddef>
#include <cstdint>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/quiche_data_reader.h"
namespace quic {
@@ -34,7 +34,7 @@
public:
// Constructs a reader using NETWORK_BYTE_ORDER endianness.
// Caller must provide an underlying buffer to work on.
- explicit QuicDataReader(quiche::QuicheStringPiece data);
+ explicit QuicDataReader(absl::string_view data);
// Constructs a reader using NETWORK_BYTE_ORDER endianness.
// Caller must provide an underlying buffer to work on.
QuicDataReader(const char* data, const size_t len);
@@ -85,7 +85,7 @@
//
// Forwards the internal iterator on success.
// Returns true on success, false otherwise.
- bool ReadStringPieceVarInt62(quiche::QuicheStringPiece* result);
+ bool ReadStringPieceVarInt62(absl::string_view* result);
};
} // namespace quic
diff --git a/quic/core/quic_data_writer.cc b/quic/core/quic_data_writer.cc
index 41c374c..3603984 100644
--- a/quic/core/quic_data_writer.cc
+++ b/quic/core/quic_data_writer.cc
@@ -7,13 +7,13 @@
#include <algorithm>
#include <limits>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
#include "net/third_party/quiche/src/quic/core/quic_constants.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -234,7 +234,7 @@
}
bool QuicDataWriter::WriteStringPieceVarInt62(
- const quiche::QuicheStringPiece& string_piece) {
+ const absl::string_view& string_piece) {
if (!WriteVarInt62(string_piece.size())) {
return false;
}
diff --git a/quic/core/quic_data_writer.h b/quic/core/quic_data_writer.h
index 3926c1a..4296b21 100644
--- a/quic/core/quic_data_writer.h
+++ b/quic/core/quic_data_writer.h
@@ -8,10 +8,10 @@
#include <cstddef>
#include <cstdint>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/quiche_data_writer.h"
namespace quic {
@@ -69,7 +69,7 @@
// Writes a string piece as a consecutive length/content pair. The
// length is VarInt62 encoded.
- bool WriteStringPieceVarInt62(const quiche::QuicheStringPiece& string_piece);
+ bool WriteStringPieceVarInt62(const absl::string_view& string_piece);
// Utility function to return the number of bytes needed to encode
// the given value using IETF VarInt62 encoding. Returns the number
diff --git a/quic/core/quic_data_writer_test.cc b/quic/core/quic_data_writer_test.cc
index e05af21..1aa4f3f 100644
--- a/quic/core/quic_data_writer_test.cc
+++ b/quic/core/quic_data_writer_test.cc
@@ -7,6 +7,7 @@
#include <cstdint>
#include <cstring>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
#include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -18,7 +19,6 @@
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
namespace quic {
@@ -1227,24 +1227,22 @@
quiche::test::CompareCharArraysWithHexError(
"first read", first_read_buffer, sizeof(first_read_buffer),
expected_first_read, sizeof(expected_first_read));
- quiche::QuicheStringPiece peeked_remaining_payload =
- reader.PeekRemainingPayload();
+ absl::string_view peeked_remaining_payload = reader.PeekRemainingPayload();
quiche::test::CompareCharArraysWithHexError(
"peeked_remaining_payload", peeked_remaining_payload.data(),
peeked_remaining_payload.length(), expected_remaining,
sizeof(expected_remaining));
- quiche::QuicheStringPiece full_payload = reader.FullPayload();
+ absl::string_view full_payload = reader.FullPayload();
quiche::test::CompareCharArraysWithHexError(
"full_payload", full_payload.data(), full_payload.length(), buffer,
sizeof(buffer));
- quiche::QuicheStringPiece read_remaining_payload =
- reader.ReadRemainingPayload();
+ absl::string_view read_remaining_payload = reader.ReadRemainingPayload();
quiche::test::CompareCharArraysWithHexError(
"read_remaining_payload", read_remaining_payload.data(),
read_remaining_payload.length(), expected_remaining,
sizeof(expected_remaining));
EXPECT_TRUE(reader.IsDoneReading());
- quiche::QuicheStringPiece full_payload2 = reader.FullPayload();
+ absl::string_view full_payload2 = reader.FullPayload();
quiche::test::CompareCharArraysWithHexError(
"full_payload2", full_payload2.data(), full_payload2.length(), buffer,
sizeof(buffer));
@@ -1253,14 +1251,13 @@
TEST_P(QuicDataWriterTest, StringPieceVarInt62) {
char inner_buffer[16] = {1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16};
- quiche::QuicheStringPiece inner_payload_write(inner_buffer,
- sizeof(inner_buffer));
+ absl::string_view inner_payload_write(inner_buffer, sizeof(inner_buffer));
char buffer[sizeof(inner_buffer) + sizeof(uint8_t)] = {};
QuicDataWriter writer(sizeof(buffer), buffer);
EXPECT_TRUE(writer.WriteStringPieceVarInt62(inner_payload_write));
EXPECT_EQ(0u, writer.remaining());
QuicDataReader reader(buffer, sizeof(buffer));
- quiche::QuicheStringPiece inner_payload_read;
+ absl::string_view inner_payload_read;
EXPECT_TRUE(reader.ReadStringPieceVarInt62(&inner_payload_read));
quiche::test::CompareCharArraysWithHexError(
"inner_payload", inner_payload_write.data(), inner_payload_write.length(),
diff --git a/quic/core/quic_datagram_queue_test.cc b/quic/core/quic_datagram_queue_test.cc
index 34ccccc..fb31e30 100644
--- a/quic/core/quic_datagram_queue_test.cc
+++ b/quic/core/quic_datagram_queue_test.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/quic_datagram_queue.h"
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_buffer_allocator.h"
#include "net/third_party/quiche/src/quic/core/quic_time.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -11,7 +12,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_optional.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
namespace test {
@@ -41,7 +41,7 @@
session_.SetCryptoStream(new EstablishedCryptoStream(&session_));
}
- QuicMemSlice CreateMemSlice(quiche::QuicheStringPiece data) {
+ QuicMemSlice CreateMemSlice(absl::string_view data) {
QuicUniqueBufferPtr buffer =
MakeUniqueBuffer(helper_.GetStreamSendBufferAllocator(), data.size());
memcpy(buffer.get(), data.data(), data.size());
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 972a9ac..ac40b0a 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -7,6 +7,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/chlo_extractor.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
@@ -22,7 +23,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_stack_trace.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 {
@@ -190,12 +190,12 @@
void OnChlo(QuicTransportVersion version,
QuicConnectionId /*server_connection_id*/,
const CryptoHandshakeMessage& chlo) override {
- quiche::QuicheStringPiece alpn_value;
+ absl::string_view alpn_value;
if (chlo.GetStringPiece(kALPN, &alpn_value)) {
alpn_ = std::string(alpn_value);
}
if (version == LegacyVersionForEncapsulation().transport_version) {
- quiche::QuicheStringPiece qlve_value;
+ absl::string_view qlve_value;
if (chlo.GetStringPiece(kQLVE, &qlve_value)) {
legacy_version_encapsulation_inner_packet_ = std::string(qlve_value);
}
@@ -231,7 +231,7 @@
ParsedQuicVersion parsed_version = ParsedQuicVersion::Unsupported();
QuicConnectionId destination_connection_id, source_connection_id;
bool retry_token_present;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
std::string detailed_error;
const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
QuicEncryptedPacket(legacy_version_encapsulation_inner_packet.data(),
@@ -338,12 +338,12 @@
const QuicReceivedPacket& packet) {
QUIC_DVLOG(2) << "Dispatcher received encrypted " << packet.length()
<< " bytes:" << std::endl
- << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
- packet.data(), packet.length()));
+ << quiche::QuicheTextUtils::HexDump(
+ absl::string_view(packet.data(), packet.length()));
ReceivedPacketInfo packet_info(self_address, peer_address, packet);
std::string detailed_error;
bool retry_token_present;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
packet, expected_server_connection_id_length_, &packet_info.form,
&packet_info.long_packet_type, &packet_info.version_flag,
diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index e4c61e5..cdc4edc 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -12,6 +12,7 @@
#include <string>
#include <vector>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_compressed_certs_cache.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
#include "net/third_party/quiche/src/quic/core/quic_blocked_writer_interface.h"
@@ -25,7 +26,6 @@
#include "net/third_party/quiche/src/quic/core/quic_version_manager.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
namespace test {
@@ -140,7 +140,7 @@
QuicConnectionId server_connection_id,
const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
- quiche::QuicheStringPiece alpn,
+ absl::string_view alpn,
const ParsedQuicVersion& version) = 0;
// Tries to validate and dispatch packet based on available information.
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index ae0d594..db1020e 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -135,7 +135,7 @@
(QuicConnectionId connection_id,
const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
- quiche::QuicheStringPiece alpn,
+ absl::string_view alpn,
const quic::ParsedQuicVersion& version),
(override));
@@ -605,7 +605,7 @@
ParsedQuicVersion parsed_version = ParsedQuicVersion::Unsupported();
QuicConnectionId destination_connection_id, source_connection_id;
bool retry_token_present;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
std::string detailed_error;
const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
QuicEncryptedPacket(packets[0]->data(), packets[0]->length()),
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index cbf1959..6b9f0c1 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -11,6 +11,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
@@ -45,7 +46,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_stack_trace.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
@@ -295,14 +295,14 @@
return NUM_ENCRYPTION_LEVELS;
}
-quiche::QuicheStringPiece TruncateErrorString(quiche::QuicheStringPiece error) {
+absl::string_view TruncateErrorString(absl::string_view error) {
if (error.length() <= kMaxErrorStringLength) {
return error;
}
- return quiche::QuicheStringPiece(error.data(), kMaxErrorStringLength);
+ return absl::string_view(error.data(), kMaxErrorStringLength);
}
-size_t TruncatedErrorStringSize(const quiche::QuicheStringPiece& error) {
+size_t TruncatedErrorStringSize(const absl::string_view& error) {
if (error.length() < kMaxErrorStringLength) {
return error.length();
}
@@ -1547,14 +1547,13 @@
const size_t retry_token_length =
bytes_remaining - kRetryIntegrityTagLength;
DCHECK_GT(retry_token_length, 0u);
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
if (!reader->ReadStringPiece(&retry_token, retry_token_length)) {
set_detailed_error("Failed to read retry token.");
return false;
}
- quiche::QuicheStringPiece retry_without_tag =
- reader->PreviouslyReadPayload();
- quiche::QuicheStringPiece integrity_tag = reader->ReadRemainingPayload();
+ absl::string_view retry_without_tag = reader->PreviouslyReadPayload();
+ absl::string_view integrity_tag = reader->ReadRemainingPayload();
DCHECK_EQ(integrity_tag.length(), kRetryIntegrityTagLength);
visitor_->OnRetryPacket(EmptyQuicConnectionId(),
header.source_connection_id, retry_token,
@@ -1591,11 +1590,11 @@
return false;
}
- quiche::QuicheStringPiece retry_token = reader->ReadRemainingPayload();
+ absl::string_view retry_token = reader->ReadRemainingPayload();
visitor_->OnRetryPacket(original_destination_connection_id,
header.source_connection_id, retry_token,
- /*retry_integrity_tag=*/quiche::QuicheStringPiece(),
- /*retry_without_tag=*/quiche::QuicheStringPiece());
+ /*retry_integrity_tag=*/absl::string_view(),
+ /*retry_without_tag=*/absl::string_view());
return true;
}
@@ -1611,8 +1610,7 @@
return;
}
- quiche::QuicheStringPiece remaining_data =
- encrypted_reader.PeekRemainingPayload();
+ absl::string_view remaining_data = encrypted_reader.PeekRemainingPayload();
DCHECK_EQ(remaining_data.length(), remaining_bytes_length);
const char* coalesced_data =
@@ -1695,8 +1693,7 @@
perspective_ == Perspective::IS_CLIENT) {
// Peek possible stateless reset token. Will only be used on decryption
// failure.
- quiche::QuicheStringPiece remaining =
- encrypted_reader->PeekRemainingPayload();
+ absl::string_view remaining = encrypted_reader->PeekRemainingPayload();
if (remaining.length() >= sizeof(header->possible_stateless_reset_token)) {
header->has_possible_stateless_reset_token = true;
memcpy(&header->possible_stateless_reset_token,
@@ -1710,7 +1707,7 @@
return false;
}
- quiche::QuicheStringPiece associated_data;
+ absl::string_view associated_data;
std::vector<char> ad_storage;
QuicPacketNumber base_packet_number;
if (header->form == IETF_QUIC_SHORT_HEADER_PACKET ||
@@ -1736,8 +1733,7 @@
&full_packet_number, &ad_storage)) {
hp_removal_failed = true;
}
- associated_data =
- quiche::QuicheStringPiece(ad_storage.data(), ad_storage.size());
+ associated_data = absl::string_view(ad_storage.data(), ad_storage.size());
} else if (!ProcessAndCalculatePacketNumber(
encrypted_reader, header->packet_number_length,
base_packet_number, &full_packet_number)) {
@@ -1801,8 +1797,7 @@
return false;
}
- quiche::QuicheStringPiece encrypted =
- encrypted_reader->ReadRemainingPayload();
+ absl::string_view encrypted = encrypted_reader->ReadRemainingPayload();
if (!version_.HasHeaderProtection()) {
associated_data = GetAssociatedDataFromEncryptedPacket(
version_.transport_version, packet,
@@ -1906,16 +1901,14 @@
return false;
}
- quiche::QuicheStringPiece encrypted =
- encrypted_reader->ReadRemainingPayload();
- quiche::QuicheStringPiece associated_data =
- GetAssociatedDataFromEncryptedPacket(
- version_.transport_version, packet,
- GetIncludedDestinationConnectionIdLength(*header),
- GetIncludedSourceConnectionIdLength(*header), header->version_flag,
- header->nonce != nullptr, header->packet_number_length,
- header->retry_token_length_length, header->retry_token.length(),
- header->length_length);
+ absl::string_view encrypted = encrypted_reader->ReadRemainingPayload();
+ absl::string_view associated_data = GetAssociatedDataFromEncryptedPacket(
+ version_.transport_version, packet,
+ GetIncludedDestinationConnectionIdLength(*header),
+ GetIncludedSourceConnectionIdLength(*header), header->version_flag,
+ header->nonce != nullptr, header->packet_number_length,
+ header->retry_token_length_length, header->retry_token.length(),
+ header->length_length);
size_t decrypted_length = 0;
EncryptionLevel decrypted_level;
@@ -1995,7 +1988,7 @@
}
// TODO(satyamshekhar): validate nonce to protect against DoS.
- quiche::QuicheStringPiece address;
+ absl::string_view address;
if (reset->GetStringPiece(kCADR, &address)) {
QuicSocketAddressCoder address_coder;
if (address_coder.Decode(address.data(), address.length())) {
@@ -2004,7 +1997,7 @@
}
}
- quiche::QuicheStringPiece endpoint_id;
+ absl::string_view endpoint_id;
if (perspective_ == Perspective::IS_CLIENT &&
reset->GetStringPiece(kEPID, &endpoint_id)) {
packet.endpoint_id = std::string(endpoint_id);
@@ -3476,8 +3469,8 @@
return false;
}
- // TODO(ianswett): Don't use quiche::QuicheStringPiece as an intermediary.
- quiche::QuicheStringPiece data;
+ // TODO(ianswett): Don't use absl::string_view as an intermediary.
+ absl::string_view data;
if (has_data_length) {
if (!reader->ReadStringPiece16(&data)) {
set_detailed_error("Unable to read frame data.");
@@ -3538,8 +3531,8 @@
frame->fin = false;
}
- // TODO(ianswett): Don't use quiche::QuicheStringPiece as an intermediary.
- quiche::QuicheStringPiece data;
+ // TODO(ianswett): Don't use absl::string_view as an intermediary.
+ absl::string_view data;
if (!reader->ReadStringPiece(&data, frame->data_length)) {
set_detailed_error("Unable to read frame data.");
return false;
@@ -3566,8 +3559,8 @@
}
frame->data_length = len;
- // TODO(ianswett): Don't use quiche::QuicheStringPiece as an intermediary.
- quiche::QuicheStringPiece data;
+ // TODO(ianswett): Don't use absl::string_view as an intermediary.
+ absl::string_view data;
if (!reader->ReadStringPiece(&data, frame->data_length)) {
set_detailed_error("Unable to read frame data.");
return false;
@@ -4069,7 +4062,7 @@
frame->wire_error_code = error_code;
frame->quic_error_code = static_cast<QuicErrorCode>(error_code);
- quiche::QuicheStringPiece error_details;
+ absl::string_view error_details;
if (!reader->ReadStringPiece16(&error_details)) {
set_detailed_error("Unable to read connection close error details.");
return false;
@@ -4101,7 +4094,7 @@
}
frame->last_good_stream_id = static_cast<QuicStreamId>(stream_id);
- quiche::QuicheStringPiece reason_phrase;
+ absl::string_view reason_phrase;
if (!reader->ReadStringPiece16(&reason_phrase)) {
set_detailed_error("Unable to read goaway reason.");
return false;
@@ -4155,7 +4148,7 @@
bool no_message_length,
QuicMessageFrame* frame) {
if (no_message_length) {
- quiche::QuicheStringPiece remaining(reader->ReadRemainingPayload());
+ absl::string_view remaining(reader->ReadRemainingPayload());
frame->data = remaining.data();
frame->message_length = remaining.length();
return true;
@@ -4167,7 +4160,7 @@
return false;
}
- quiche::QuicheStringPiece message_piece;
+ absl::string_view message_piece;
if (!reader->ReadStringPiece(&message_piece, message_length)) {
set_detailed_error("Unable to read message data");
return false;
@@ -4180,7 +4173,7 @@
}
// static
-quiche::QuicheStringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
+absl::string_view QuicFramer::GetAssociatedDataFromEncryptedPacket(
QuicTransportVersion version,
const QuicEncryptedPacket& encrypted,
QuicConnectionIdLength destination_connection_id_length,
@@ -4192,7 +4185,7 @@
uint64_t retry_token_length,
QuicVariableLengthIntegerLength length_length) {
// TODO(ianswett): This is identical to QuicData::AssociatedData.
- return quiche::QuicheStringPiece(
+ return absl::string_view(
encrypted.data(),
GetStartOfEncryptedData(version, destination_connection_id_length,
source_connection_id_length, includes_version,
@@ -4297,10 +4290,10 @@
size_t output_length = 0;
if (!encrypter_[level]->EncryptPacket(
packet_number.ToUint64(),
- quiche::QuicheStringPiece(buffer, ad_len), // Associated data
- quiche::QuicheStringPiece(buffer + ad_len,
- total_len - ad_len), // Plaintext
- buffer + ad_len, // Destination buffer
+ absl::string_view(buffer, ad_len), // Associated data
+ absl::string_view(buffer + ad_len,
+ total_len - ad_len), // Plaintext
+ buffer + ad_len, // Destination buffer
&output_length, buffer_len - ad_len)) {
RaiseError(QUIC_ENCRYPTION_FAILURE);
return 0;
@@ -4339,7 +4332,7 @@
// Sample the ciphertext and generate the mask to use for header protection.
size_t sample_offset = pn_offset + 4;
QuicDataReader sample_reader(buffer, buffer_len);
- quiche::QuicheStringPiece sample;
+ absl::string_view sample;
if (!sample_reader.Seek(sample_offset) ||
!sample_reader.ReadStringPiece(&sample, kHPSampleLen)) {
QUIC_BUG << "Not enough bytes to sample: sample_offset " << sample_offset
@@ -4434,11 +4427,11 @@
// Read a sample from the ciphertext and compute the mask to use for header
// protection.
- quiche::QuicheStringPiece remaining_packet = reader->PeekRemainingPayload();
+ absl::string_view remaining_packet = reader->PeekRemainingPayload();
QuicDataReader sample_reader(remaining_packet);
// The sample starts 4 bytes after the start of the packet number.
- quiche::QuicheStringPiece pn;
+ absl::string_view pn;
if (!sample_reader.ReadStringPiece(&pn, 4)) {
QUIC_DVLOG(1) << "Not enough data to sample";
return false;
@@ -4506,7 +4499,7 @@
}
// Get the associated data, and apply the same unmasking operations to it.
- quiche::QuicheStringPiece ad = GetAssociatedDataFromEncryptedPacket(
+ absl::string_view ad = GetAssociatedDataFromEncryptedPacket(
version_.transport_version, packet,
GetIncludedDestinationConnectionIdLength(*header),
GetIncludedSourceConnectionIdLength(*header), header->version_flag,
@@ -4548,7 +4541,7 @@
return 0;
}
- quiche::QuicheStringPiece associated_data =
+ absl::string_view associated_data =
packet.AssociatedData(version_.transport_version);
// Copy in the header, because the encrypter only populates the encrypted
// plaintext content.
@@ -4609,8 +4602,8 @@
return min_plaintext_size;
}
-bool QuicFramer::DecryptPayload(quiche::QuicheStringPiece encrypted,
- quiche::QuicheStringPiece associated_data,
+bool QuicFramer::DecryptPayload(absl::string_view encrypted,
+ absl::string_view associated_data,
const QuicPacketHeader& header,
char* decrypted_buffer,
size_t buffer_length,
@@ -5142,8 +5135,8 @@
return false;
}
- // TODO(ianswett): Don't use quiche::QuicheStringPiece as an intermediary.
- quiche::QuicheStringPiece data;
+ // TODO(ianswett): Don't use absl::string_view as an intermediary.
+ absl::string_view data;
if (!reader->ReadStringPiece(&data, length)) {
set_detailed_error("Unable to read new token data.");
return false;
@@ -5813,7 +5806,7 @@
return false;
}
- quiche::QuicheStringPiece phrase;
+ absl::string_view phrase;
if (!reader->ReadStringPiece(&phrase, static_cast<size_t>(phrase_length))) {
set_detailed_error("Unable to read connection close error details.");
return false;
@@ -6284,7 +6277,7 @@
QuicConnectionId* destination_connection_id,
QuicConnectionId* source_connection_id,
bool* retry_token_present,
- quiche::QuicheStringPiece* retry_token,
+ absl::string_view* retry_token,
std::string* detailed_error) {
QuicDataReader reader(packet.data(), packet.length());
if (reader.IsDoneReading()) {
@@ -6454,7 +6447,7 @@
QuicConnectionId* source_connection_id,
QuicLongHeaderType* long_packet_type,
QuicVariableLengthIntegerLength* retry_token_length_length,
- quiche::QuicheStringPiece* retry_token,
+ absl::string_view* retry_token,
std::string* detailed_error) {
*version_present = false;
*has_length_prefix = false;
@@ -6463,7 +6456,7 @@
*source_connection_id = EmptyQuicConnectionId();
*long_packet_type = INVALID_PACKET_TYPE;
*retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
- *retry_token = quiche::QuicheStringPiece();
+ *retry_token = absl::string_view();
*detailed_error = "";
if (!reader->ReadUInt8(first_byte)) {
@@ -6738,7 +6731,7 @@
// the string is not found, or is not properly formed, it returns
// ErrorCode::QUIC_IETF_GQUIC_ERROR_MISSING
void MaybeExtractQuicErrorCode(QuicConnectionCloseFrame* frame) {
- std::vector<quiche::QuicheStringPiece> ed =
+ std::vector<absl::string_view> ed =
quiche::QuicheTextUtils::Split(frame->error_details, ':');
uint64_t extracted_error_code;
if (ed.size() < 2 || !quiche::QuicheTextUtils::IsAllDigits(ed[0]) ||
@@ -6756,7 +6749,7 @@
// including, the split character, so the length of ed[0] is just the number
// of digits in the error number. In removing the prefix, 1 is added to the
// length to account for the :
- quiche::QuicheStringPiece x = quiche::QuicheStringPiece(frame->error_details);
+ absl::string_view x = absl::string_view(frame->error_details);
x.remove_prefix(ed[0].length() + 1);
frame->error_details = std::string(x);
frame->quic_error_code = static_cast<QuicErrorCode>(extracted_error_code);
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index c9820d4..e57e252 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -10,6 +10,7 @@
#include <memory>
#include <string>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
@@ -17,7 +18,6 @@
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -106,9 +106,9 @@
// the entire RETRY packet except the Retry Integrity Tag field.
virtual void OnRetryPacket(QuicConnectionId original_connection_id,
QuicConnectionId new_connection_id,
- quiche::QuicheStringPiece retry_token,
- quiche::QuicheStringPiece retry_integrity_tag,
- quiche::QuicheStringPiece retry_without_tag) = 0;
+ absl::string_view retry_token,
+ absl::string_view retry_integrity_tag,
+ absl::string_view retry_without_tag) = 0;
// Called when all fields except packet number has been parsed, but has not
// been authenticated. If it returns false, framing for this packet will
@@ -385,7 +385,7 @@
// Returns the associated data from the encrypted packet |encrypted| as a
// stringpiece.
- static quiche::QuicheStringPiece GetAssociatedDataFromEncryptedPacket(
+ static absl::string_view GetAssociatedDataFromEncryptedPacket(
QuicTransportVersion version,
const QuicEncryptedPacket& encrypted,
QuicConnectionIdLength destination_connection_id_length,
@@ -414,7 +414,7 @@
QuicConnectionId* source_connection_id,
QuicLongHeaderType* long_packet_type,
QuicVariableLengthIntegerLength* retry_token_length_length,
- quiche::QuicheStringPiece* retry_token,
+ absl::string_view* retry_token,
std::string* detailed_error);
// Parses the unencrypted fields in |packet| and stores them in the other
@@ -432,7 +432,7 @@
QuicConnectionId* destination_connection_id,
QuicConnectionId* source_connection_id,
bool* retry_token_present,
- quiche::QuicheStringPiece* retry_token,
+ absl::string_view* retry_token,
std::string* detailed_error);
// Serializes a packet containing |frames| into |buffer|.
@@ -808,8 +808,8 @@
bool no_message_length,
QuicMessageFrame* frame);
- bool DecryptPayload(quiche::QuicheStringPiece encrypted,
- quiche::QuicheStringPiece associated_data,
+ bool DecryptPayload(absl::string_view encrypted,
+ absl::string_view associated_data,
const QuicPacketHeader& header,
char* decrypted_buffer,
size_t buffer_length,
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 688aa02..f35613a 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -12,6 +12,7 @@
#include <utility>
#include <vector>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
@@ -31,7 +32,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_data_producer.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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/common/test_tools/quiche_test_utils.h"
@@ -92,17 +92,17 @@
class TestEncrypter : public QuicEncrypter {
public:
~TestEncrypter() override {}
- bool SetKey(quiche::QuicheStringPiece /*key*/) override { return true; }
- bool SetNoncePrefix(quiche::QuicheStringPiece /*nonce_prefix*/) override {
+ bool SetKey(absl::string_view /*key*/) override { return true; }
+ bool SetNoncePrefix(absl::string_view /*nonce_prefix*/) override {
return true;
}
- bool SetIV(quiche::QuicheStringPiece /*iv*/) override { return true; }
- bool SetHeaderProtectionKey(quiche::QuicheStringPiece /*key*/) override {
+ bool SetIV(absl::string_view /*iv*/) override { return true; }
+ bool SetHeaderProtectionKey(absl::string_view /*key*/) override {
return true;
}
bool EncryptPacket(uint64_t packet_number,
- quiche::QuicheStringPiece associated_data,
- quiche::QuicheStringPiece plaintext,
+ absl::string_view associated_data,
+ absl::string_view plaintext,
char* output,
size_t* output_length,
size_t /*max_output_length*/) override {
@@ -114,7 +114,7 @@
return true;
}
std::string GenerateHeaderProtectionMask(
- quiche::QuicheStringPiece /*sample*/) override {
+ absl::string_view /*sample*/) override {
return std::string(5, 0);
}
size_t GetKeySize() const override { return 0; }
@@ -126,11 +126,9 @@
size_t GetCiphertextSize(size_t plaintext_size) const override {
return plaintext_size;
}
- quiche::QuicheStringPiece GetKey() const override {
- return quiche::QuicheStringPiece();
- }
- quiche::QuicheStringPiece GetNoncePrefix() const override {
- return quiche::QuicheStringPiece();
+ absl::string_view GetKey() const override { return absl::string_view(); }
+ absl::string_view GetNoncePrefix() const override {
+ return absl::string_view();
}
QuicPacketNumber packet_number_;
@@ -141,15 +139,15 @@
class TestDecrypter : public QuicDecrypter {
public:
~TestDecrypter() override {}
- bool SetKey(quiche::QuicheStringPiece /*key*/) override { return true; }
- bool SetNoncePrefix(quiche::QuicheStringPiece /*nonce_prefix*/) override {
+ bool SetKey(absl::string_view /*key*/) override { return true; }
+ bool SetNoncePrefix(absl::string_view /*nonce_prefix*/) override {
return true;
}
- bool SetIV(quiche::QuicheStringPiece /*iv*/) override { return true; }
- bool SetHeaderProtectionKey(quiche::QuicheStringPiece /*key*/) override {
+ bool SetIV(absl::string_view /*iv*/) override { return true; }
+ bool SetHeaderProtectionKey(absl::string_view /*key*/) override {
return true;
}
- bool SetPreliminaryKey(quiche::QuicheStringPiece /*key*/) override {
+ bool SetPreliminaryKey(absl::string_view /*key*/) override {
QUIC_BUG << "should not be called";
return false;
}
@@ -157,8 +155,8 @@
return true;
}
bool DecryptPacket(uint64_t packet_number,
- quiche::QuicheStringPiece associated_data,
- quiche::QuicheStringPiece ciphertext,
+ absl::string_view associated_data,
+ absl::string_view ciphertext,
char* output,
size_t* output_length,
size_t /*max_output_length*/) override {
@@ -176,11 +174,9 @@
size_t GetKeySize() const override { return 0; }
size_t GetNoncePrefixSize() const override { return 0; }
size_t GetIVSize() const override { return 0; }
- quiche::QuicheStringPiece GetKey() const override {
- return quiche::QuicheStringPiece();
- }
- quiche::QuicheStringPiece GetNoncePrefix() const override {
- return quiche::QuicheStringPiece();
+ absl::string_view GetKey() const override { return absl::string_view(); }
+ absl::string_view GetNoncePrefix() const override {
+ return absl::string_view();
}
// Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
uint32_t cipher_id() const override { return 0xFFFFFFF2; }
@@ -224,9 +220,9 @@
void OnRetryPacket(QuicConnectionId original_connection_id,
QuicConnectionId new_connection_id,
- quiche::QuicheStringPiece retry_token,
- quiche::QuicheStringPiece retry_integrity_tag,
- quiche::QuicheStringPiece retry_without_tag) override {
+ absl::string_view retry_token,
+ absl::string_view retry_integrity_tag,
+ absl::string_view retry_without_tag) override {
on_retry_packet_called_ = true;
retry_original_connection_id_ =
std::make_unique<QuicConnectionId>(original_connection_id);
@@ -707,7 +703,7 @@
<< " actual: " << decrypter_->packet_number_;
return false;
}
- quiche::QuicheStringPiece associated_data =
+ absl::string_view associated_data =
QuicFramer::GetAssociatedDataFromEncryptedPacket(
framer_.transport_version(), encrypted,
destination_connection_id_length, source_connection_id_length,
@@ -722,7 +718,7 @@
decrypter_->associated_data_);
return false;
}
- quiche::QuicheStringPiece ciphertext(
+ absl::string_view ciphertext(
encrypted.AsStringPiece().substr(GetStartOfEncryptedData(
framer_.transport_version(), destination_connection_id_length,
source_connection_id_length, includes_version,
@@ -1070,7 +1066,7 @@
QuicVersionLabel version_label;
std::string detailed_error;
bool retry_token_present, use_length_prefix;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
const QuicErrorCode error_code = QuicFramer::ParsePublicHeaderDispatcher(
*encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
@@ -1135,7 +1131,7 @@
QuicVersionLabel version_label;
std::string detailed_error;
bool retry_token_present, use_length_prefix;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
const QuicErrorCode error_code = QuicFramer::ParsePublicHeaderDispatcher(
*encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
@@ -1215,7 +1211,7 @@
QuicVersionLabel version_label = 0;
std::string detailed_error = "";
bool retry_token_present, use_length_prefix;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
const QuicErrorCode error_code = QuicFramer::ParsePublicHeaderDispatcher(
encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
@@ -1305,7 +1301,7 @@
QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
QuicVariableLengthIntegerLength retry_token_length_length =
VARIABLE_LENGTH_INTEGER_LENGTH_4;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
std::string detailed_error = "foobar";
QuicDataReader reader(AsChars(p), p_length);
@@ -1328,7 +1324,7 @@
EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
EXPECT_EQ(VARIABLE_LENGTH_INTEGER_LENGTH_0, retry_token_length_length);
- EXPECT_EQ(quiche::QuicheStringPiece(), retry_token);
+ EXPECT_EQ(absl::string_view(), retry_token);
if (VersionHasIetfInvariantHeader(framer_.transport_version())) {
EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
EXPECT_EQ(HANDSHAKE, long_packet_type);
@@ -1375,7 +1371,7 @@
QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
QuicVariableLengthIntegerLength retry_token_length_length =
VARIABLE_LENGTH_INTEGER_LENGTH_4;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
std::string detailed_error = "foobar";
QuicDataReader reader(AsChars(p), p_length);
@@ -1395,7 +1391,7 @@
EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
EXPECT_EQ(VARIABLE_LENGTH_INTEGER_LENGTH_0, retry_token_length_length);
- EXPECT_EQ(quiche::QuicheStringPiece(), retry_token);
+ EXPECT_EQ(absl::string_view(), retry_token);
EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
}
@@ -6167,7 +6163,7 @@
header.version_flag = false;
header.packet_number = kPacketNumber;
QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
- quiche::QuicheStringPiece("hello world!"));
+ absl::string_view("hello world!"));
QuicPaddingFrame padding_frame(2);
QuicFrames frames = {QuicFrame(padding_frame), QuicFrame(stream_frame),
QuicFrame(padding_frame)};
@@ -6510,7 +6506,7 @@
}
QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
- quiche::QuicheStringPiece("hello world!"));
+ absl::string_view("hello world!"));
QuicFrames frames = {QuicFrame(stream_frame)};
@@ -6609,7 +6605,7 @@
}
QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
- quiche::QuicheStringPiece("hello world!"));
+ absl::string_view("hello world!"));
QuicFrames frames = {QuicFrame(stream_frame)};
// clang-format off
@@ -6742,7 +6738,7 @@
SimpleDataProducer data_producer;
framer_.set_data_producer(&data_producer);
- quiche::QuicheStringPiece crypto_frame_contents("hello world!");
+ absl::string_view crypto_frame_contents("hello world!");
QuicCryptoFrame crypto_frame(ENCRYPTION_INITIAL, kStreamOffset,
crypto_frame_contents.length());
data_producer.SaveCryptoData(ENCRYPTION_INITIAL, kStreamOffset,
@@ -14029,7 +14025,7 @@
QuicConnectionId destination_connection_id = TestConnectionId(0x33);
QuicConnectionId source_connection_id = TestConnectionId(0x34);
bool retry_token_present = true;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
std::string detailed_error = "foobar";
QuicErrorCode parse_result = QuicFramer::ParsePublicHeaderDispatcher(
@@ -14046,7 +14042,7 @@
EXPECT_EQ(probe_payload_connection_id, destination_connection_id);
EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
EXPECT_FALSE(retry_token_present);
- EXPECT_EQ(quiche::QuicheStringPiece(), retry_token);
+ EXPECT_EQ(absl::string_view(), retry_token);
EXPECT_EQ("", detailed_error);
}
@@ -14181,7 +14177,7 @@
QuicConnectionId destination_connection_id = TestConnectionId(1);
QuicConnectionId source_connection_id = TestConnectionId(2);
bool retry_token_present = true;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
std::string detailed_error = "foobar";
QuicErrorCode header_parse_result = QuicFramer::ParsePublicHeaderDispatcher(
encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
@@ -14260,7 +14256,7 @@
QuicConnectionId destination_connection_id = TestConnectionId(1);
QuicConnectionId source_connection_id = TestConnectionId(2);
bool retry_token_present = true;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
std::string detailed_error = "foobar";
QuicErrorCode header_parse_result = QuicFramer::ParsePublicHeaderDispatcher(
encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
diff --git a/quic/core/quic_legacy_version_encapsulator.cc b/quic/core/quic_legacy_version_encapsulator.cc
index 4afd342..8e93172 100644
--- a/quic/core/quic_legacy_version_encapsulator.cc
+++ b/quic/core/quic_legacy_version_encapsulator.cc
@@ -19,7 +19,7 @@
// static
QuicByteCount QuicLegacyVersionEncapsulator::GetMinimumOverhead(
- quiche::QuicheStringPiece sni) {
+ absl::string_view sni) {
// The number 52 is the sum of:
// - Flags (1 byte)
// - Server Connection ID (8 bytes)
@@ -85,8 +85,8 @@
// static
QuicPacketLength QuicLegacyVersionEncapsulator::Encapsulate(
- quiche::QuicheStringPiece sni,
- quiche::QuicheStringPiece inner_packet,
+ absl::string_view sni,
+ absl::string_view inner_packet,
const QuicConnectionId& server_connection_id,
QuicTime creation_time,
QuicByteCount outer_max_packet_length,
diff --git a/quic/core/quic_legacy_version_encapsulator.h b/quic/core/quic_legacy_version_encapsulator.h
index 413829b..7a4ada6 100644
--- a/quic/core/quic_legacy_version_encapsulator.h
+++ b/quic/core/quic_legacy_version_encapsulator.h
@@ -5,11 +5,11 @@
#ifndef QUICHE_QUIC_CORE_QUIC_LEGACY_VERSION_ENCAPSULATOR_H_
#define QUICHE_QUIC_CORE_QUIC_LEGACY_VERSION_ENCAPSULATOR_H_
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_packet_creator.h"
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -27,8 +27,8 @@
// the contents of the encapsulated packet to |out|. |out| must point to a
// valid memory buffer capable of holding kMaxOutgoingPacketSize bytes.
static QuicPacketLength Encapsulate(
- quiche::QuicheStringPiece sni,
- quiche::QuicheStringPiece inner_packet,
+ absl::string_view sni,
+ absl::string_view inner_packet,
const QuicConnectionId& server_connection_id,
QuicTime creation_time,
QuicByteCount outer_max_packet_length,
@@ -37,7 +37,7 @@
// Returns the number of bytes of minimum overhead caused by Legacy Version
// Encapsulation, based on the length of the provided server name |sni|.
// The overhead may be higher due to extra padding added.
- static QuicByteCount GetMinimumOverhead(quiche::QuicheStringPiece sni);
+ static QuicByteCount GetMinimumOverhead(absl::string_view sni);
// Overrides for QuicPacketCreator::DelegateInterface.
QuicPacketBuffer GetPacketBuffer() override;
diff --git a/quic/core/quic_legacy_version_encapsulator_test.cc b/quic/core/quic_legacy_version_encapsulator_test.cc
index a71b2f4..d765fff 100644
--- a/quic/core/quic_legacy_version_encapsulator_test.cc
+++ b/quic/core/quic_legacy_version_encapsulator_test.cc
@@ -4,11 +4,11 @@
#include "net/third_party/quiche/src/quic/core/quic_legacy_version_encapsulator.h"
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_versions.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
@@ -43,7 +43,7 @@
ParsedQuicVersion parsed_version = ParsedQuicVersion::Unsupported();
QuicConnectionId destination_connection_id, source_connection_id;
bool retry_token_present;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
std::string detailed_error;
const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
QuicEncryptedPacket(outer_buffer_, encapsulated_length_),
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index af9d079..85960c4 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -11,6 +11,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_frame.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_path_challenge_frame.h"
@@ -31,7 +32,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_server_stats.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
@@ -1291,16 +1291,16 @@
return VARIABLE_LENGTH_INTEGER_LENGTH_0;
}
-quiche::QuicheStringPiece QuicPacketCreator::GetRetryToken() const {
+absl::string_view QuicPacketCreator::GetRetryToken() const {
if (QuicVersionHasLongHeaderLengths(framer_->transport_version()) &&
HasIetfLongHeader() &&
EncryptionlevelToLongHeaderType(packet_.encryption_level) == INITIAL) {
return retry_token_;
}
- return quiche::QuicheStringPiece();
+ return absl::string_view();
}
-void QuicPacketCreator::SetRetryToken(quiche::QuicheStringPiece retry_token) {
+void QuicPacketCreator::SetRetryToken(absl::string_view retry_token) {
retry_token_ = std::string(retry_token);
}
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index b65bd27..882b17d 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -20,6 +20,7 @@
#include <utility>
#include <vector>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_stream_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_circular_deque.h"
#include "net/third_party/quiche/src/quic/core/quic_coalesced_packet.h"
@@ -28,7 +29,6 @@
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_macros.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
namespace test {
@@ -322,7 +322,7 @@
void AddPendingPadding(QuicByteCount size);
// Sets the retry token to be sent over the wire in IETF Initial packets.
- void SetRetryToken(quiche::QuicheStringPiece retry_token);
+ void SetRetryToken(absl::string_view retry_token);
// Consumes retransmittable control |frame|. Returns true if the frame is
// successfully consumed. Returns false otherwise.
@@ -573,7 +573,7 @@
// Returns the retry token to send over the wire, only sent in
// v99 IETF Initial packets.
- quiche::QuicheStringPiece GetRetryToken() const;
+ absl::string_view GetRetryToken() const;
// Returns length of the length variable length integer to send over the
// wire. Is non-zero for v99 IETF Initial, 0-RTT or Handshake packets.
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 4afbf06..c31d3c7 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -11,6 +11,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
@@ -32,7 +33,6 @@
#include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
using testing::_;
@@ -227,8 +227,7 @@
producer_.WriteStreamData(stream_id, frame.stream_frame.offset,
frame.stream_frame.data_length, &writer);
}
- EXPECT_EQ(data,
- quiche::QuicheStringPiece(buf, frame.stream_frame.data_length));
+ EXPECT_EQ(data, absl::string_view(buf, frame.stream_frame.data_length));
EXPECT_EQ(offset, frame.stream_frame.offset);
EXPECT_EQ(fin, frame.stream_frame.fin);
}
@@ -306,7 +305,7 @@
client_framer_.transport_version(), Perspective::IS_CLIENT);
if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
frames_.push_back(QuicFrame(
- QuicStreamFrame(stream_id, false, 0u, quiche::QuicheStringPiece())));
+ QuicStreamFrame(stream_id, false, 0u, absl::string_view())));
}
SerializedPacket serialized = SerializeAllFrames(frames_);
EXPECT_EQ(level, serialized.encryption_level);
@@ -1296,7 +1295,7 @@
if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
QuicStreamFrame stream_frame(
QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
- /*fin=*/false, 0u, quiche::QuicheStringPiece());
+ /*fin=*/false, 0u, absl::string_view());
frames_.push_back(QuicFrame(stream_frame));
} else {
producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
@@ -1333,7 +1332,7 @@
if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
QuicStreamFrame stream_frame(
QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
- /*fin=*/false, 0u, quiche::QuicheStringPiece());
+ /*fin=*/false, 0u, absl::string_view());
frames_.push_back(QuicFrame(stream_frame));
} else {
producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
@@ -1556,7 +1555,7 @@
creator_.set_encryption_level(ENCRYPTION_INITIAL);
EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
QuicStreamFrame stream_frame(GetNthClientInitiatedStreamId(0),
- /*fin=*/false, 0u, quiche::QuicheStringPiece());
+ /*fin=*/false, 0u, absl::string_view());
EXPECT_QUIC_BUG(
creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION),
"Cannot send stream data with level: ENCRYPTION_INITIAL");
@@ -1571,7 +1570,7 @@
creator_.set_encryption_level(ENCRYPTION_HANDSHAKE);
EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
QuicStreamFrame stream_frame(GetNthClientInitiatedStreamId(0),
- /*fin=*/false, 0u, quiche::QuicheStringPiece());
+ /*fin=*/false, 0u, absl::string_view());
EXPECT_QUIC_BUG(
creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION),
"Cannot send stream data with level: ENCRYPTION_HANDSHAKE");
@@ -1598,9 +1597,8 @@
message_data = framer.ConstructHandshakeMessage(message);
struct iovec iov;
- MakeIOVector(
- quiche::QuicheStringPiece(message_data->data(), message_data->length()),
- &iov);
+ MakeIOVector(absl::string_view(message_data->data(), message_data->length()),
+ &iov);
QuicFrame frame;
EXPECT_CALL(delegate_, OnUnrecoverableError(QUIC_CRYPTO_CHLO_TOO_LARGE, _));
EXPECT_QUIC_BUG(
@@ -1677,7 +1675,7 @@
.WillRepeatedly(
Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
// Send stream frame of size kStreamFramePayloadSize.
- MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
+ MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize), &iov_);
creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len,
0u, 0u, false, false,
NOT_RETRANSMISSION, &frame);
@@ -1685,8 +1683,7 @@
// 1 byte padding is sent.
EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes());
// Send stream frame of size kStreamFramePayloadSize + 1.
- MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize + 1),
- &iov_);
+ MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize + 1), &iov_);
creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len,
0u, kStreamFramePayloadSize, false,
false, NOT_RETRANSMISSION, &frame);
@@ -1798,7 +1795,7 @@
creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
}
std::string message_data(kDefaultMaxPacketSize, 'a');
- quiche::QuicheStringPiece message_buffer(message_data);
+ absl::string_view message_buffer(message_data);
QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
// Test all possible encryption levels of message frames.
for (EncryptionLevel level :
@@ -1809,10 +1806,9 @@
message_size <= creator_.GetCurrentLargestMessagePayload();
++message_size) {
QuicMessageFrame* frame = new QuicMessageFrame(
- 0, MakeSpan(
- &allocator_,
- quiche::QuicheStringPiece(message_buffer.data(), message_size),
- &storage));
+ 0, MakeSpan(&allocator_,
+ absl::string_view(message_buffer.data(), message_size),
+ &storage));
EXPECT_TRUE(creator_.AddFrame(QuicFrame(frame), NOT_RETRANSMISSION));
EXPECT_TRUE(creator_.HasPendingFrames());
@@ -1938,7 +1934,7 @@
client_framer_.transport_version(), Perspective::IS_CLIENT);
QuicFrame stream_frame(QuicStreamFrame(stream_id,
/*fin=*/false, 0u,
- quiche::QuicheStringPiece()));
+ absl::string_view()));
ASSERT_TRUE(QuicUtils::IsRetransmittableFrame(stream_frame.type));
QuicFrame padding_frame{QuicPaddingFrame()};
@@ -1979,7 +1975,7 @@
if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
QuicStreamFrame stream_frame(
QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
- /*fin=*/false, 0u, quiche::QuicheStringPiece());
+ /*fin=*/false, 0u, absl::string_view());
frames_.push_back(QuicFrame(stream_frame));
} else {
producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
@@ -2146,8 +2142,8 @@
QuicAckFrame ack_frame(InitAckFrame(1));
frames_.push_back(QuicFrame(&ack_frame));
if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
- frames_.push_back(QuicFrame(
- QuicStreamFrame(1, false, 0u, quiche::QuicheStringPiece())));
+ frames_.push_back(
+ QuicFrame(QuicStreamFrame(1, false, 0u, absl::string_view())));
}
SerializedPacket serialized = SerializeAllFrames(frames_);
EXPECT_EQ(level, serialized.encryption_level);
@@ -2420,7 +2416,7 @@
}
size_t ConsumeCryptoData(EncryptionLevel level,
- quiche::QuicheStringPiece data,
+ absl::string_view data,
QuicStreamOffset offset) {
producer_->SaveCryptoData(level, offset, data);
if (!has_ack() && delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
@@ -3576,7 +3572,7 @@
ConnectionCloseFrameLargerThanPacketSize) {
delegate_.SetCanWriteAnything();
char buf[2000] = {};
- quiche::QuicheStringPiece error_details(buf, 2000);
+ absl::string_view error_details(buf, 2000);
const QuicErrorCode kQuicErrorCode = QUIC_PACKET_WRITE_ERROR;
QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame(
@@ -3616,7 +3612,7 @@
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(
Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
- MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
+ MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize), &iov_);
QuicConsumedData consumed = creator_.ConsumeData(
kDataStreamId, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
creator_.Flush();
@@ -3659,7 +3655,7 @@
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillRepeatedly(
Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
- MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
+ MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize), &iov_);
QuicConsumedData consumed = creator_.ConsumeData(
kDataStreamId, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
creator_.Flush();
@@ -3714,11 +3710,11 @@
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillRepeatedly(
Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
- MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
+ MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize), &iov_);
QuicConsumedData consumed = creator_.ConsumeData(
kDataStreamId1, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
- MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
+ MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize), &iov_);
consumed = creator_.ConsumeData(kDataStreamId2, &iov_, 1u, iov_.iov_len, 0,
FIN_AND_PADDING);
EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc
index f54cf00..0325909 100644
--- a/quic/core/quic_packets.cc
+++ b/quic/core/quic_packets.cc
@@ -6,6 +6,7 @@
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
@@ -14,7 +15,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_string_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
@@ -185,7 +185,7 @@
long_packet_type(INITIAL),
possible_stateless_reset_token(0),
retry_token_length_length(VARIABLE_LENGTH_INTEGER_LENGTH_0),
- retry_token(quiche::QuicheStringPiece()),
+ retry_token(absl::string_view()),
length_length(VARIABLE_LENGTH_INTEGER_LENGTH_0),
remaining_packet_length(0) {}
@@ -263,8 +263,8 @@
}
if (header.nonce != nullptr) {
os << ", diversification_nonce: "
- << quiche::QuicheTextUtils::HexEncode(quiche::QuicheStringPiece(
- header.nonce->data(), header.nonce->size()));
+ << quiche::QuicheTextUtils::HexEncode(
+ absl::string_view(header.nonce->data(), header.nonce->size()));
}
os << ", packet_number: " << header.packet_number << " }\n";
return os;
@@ -276,7 +276,7 @@
QuicData::QuicData(const char* buffer, size_t length, bool owns_buffer)
: buffer_(buffer), length_(length), owns_buffer_(owns_buffer) {}
-QuicData::QuicData(quiche::QuicheStringPiece packet_data)
+QuicData::QuicData(absl::string_view packet_data)
: buffer_(packet_data.data()),
length_(packet_data.length()),
owns_buffer_(false) {}
@@ -335,7 +335,7 @@
bool owns_buffer)
: QuicData(buffer, length, owns_buffer) {}
-QuicEncryptedPacket::QuicEncryptedPacket(quiche::QuicheStringPiece data)
+QuicEncryptedPacket::QuicEncryptedPacket(absl::string_view data)
: QuicData(data) {}
std::unique_ptr<QuicEncryptedPacket> QuicEncryptedPacket::Clone() const {
@@ -426,9 +426,9 @@
return os;
}
-quiche::QuicheStringPiece QuicPacket::AssociatedData(
+absl::string_view QuicPacket::AssociatedData(
QuicTransportVersion version) const {
- return quiche::QuicheStringPiece(
+ return absl::string_view(
data(),
GetStartOfEncryptedData(version, destination_connection_id_length_,
source_connection_id_length_, includes_version_,
@@ -437,14 +437,13 @@
retry_token_length_, length_length_));
}
-quiche::QuicheStringPiece QuicPacket::Plaintext(
- QuicTransportVersion version) const {
+absl::string_view QuicPacket::Plaintext(QuicTransportVersion version) const {
const size_t start_of_encrypted_data = GetStartOfEncryptedData(
version, destination_connection_id_length_, source_connection_id_length_,
includes_version_, includes_diversification_nonce_, packet_number_length_,
retry_token_length_length_, retry_token_length_, length_length_);
- return quiche::QuicheStringPiece(data() + start_of_encrypted_data,
- length() - start_of_encrypted_data);
+ return absl::string_view(data() + start_of_encrypted_data,
+ length() - start_of_encrypted_data);
}
SerializedPacket::SerializedPacket(QuicPacketNumber packet_number,
diff --git a/quic/core/quic_packets.h b/quic/core/quic_packets.h
index e9c811c..8cf7305 100644
--- a/quic/core/quic_packets.h
+++ b/quic/core/quic_packets.h
@@ -14,6 +14,7 @@
#include <utility>
#include <vector>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_ack_listener_interface.h"
#include "net/third_party/quiche/src/quic/core/quic_bandwidth.h"
@@ -25,7 +26,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -160,7 +160,7 @@
// carried only by v99 IETF Initial packets.
QuicVariableLengthIntegerLength retry_token_length_length;
// Retry token, carried only by v99 IETF Initial packets.
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
// Length of the length variable length integer field,
// carried only by v99 IETF Initial, 0-RTT and Handshake packets.
QuicVariableLengthIntegerLength length_length;
@@ -211,15 +211,15 @@
// Creates a QuicData from a buffer and length,
// optionally taking ownership of the buffer.
QuicData(const char* buffer, size_t length, bool owns_buffer);
- // Creates a QuicData from a quiche::QuicheStringPiece. Does not own the
+ // Creates a QuicData from a absl::string_view. Does not own the
// buffer.
- QuicData(quiche::QuicheStringPiece data);
+ QuicData(absl::string_view data);
QuicData(const QuicData&) = delete;
QuicData& operator=(const QuicData&) = delete;
virtual ~QuicData();
- quiche::QuicheStringPiece AsStringPiece() const {
- return quiche::QuicheStringPiece(data(), length());
+ absl::string_view AsStringPiece() const {
+ return absl::string_view(data(), length());
}
const char* data() const { return buffer_; }
@@ -252,8 +252,8 @@
QuicPacket(const QuicPacket&) = delete;
QuicPacket& operator=(const QuicPacket&) = delete;
- quiche::QuicheStringPiece AssociatedData(QuicTransportVersion version) const;
- quiche::QuicheStringPiece Plaintext(QuicTransportVersion version) const;
+ absl::string_view AssociatedData(QuicTransportVersion version) const;
+ absl::string_view Plaintext(QuicTransportVersion version) const;
char* mutable_data() { return buffer_; }
@@ -277,9 +277,9 @@
// Creates a QuicEncryptedPacket from a buffer and length,
// optionally taking ownership of the buffer.
QuicEncryptedPacket(const char* buffer, size_t length, bool owns_buffer);
- // Creates a QuicEncryptedPacket from a quiche::QuicheStringPiece.
+ // Creates a QuicEncryptedPacket from a absl::string_view.
// Does not own the buffer.
- QuicEncryptedPacket(quiche::QuicheStringPiece data);
+ QuicEncryptedPacket(absl::string_view data);
QuicEncryptedPacket(const QuicEncryptedPacket&) = delete;
QuicEncryptedPacket& operator=(const QuicEncryptedPacket&) = delete;
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index c186f65..ef651a7 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -7,6 +7,7 @@
#include <memory>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_ack_frequency_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_time.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
@@ -16,7 +17,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_sent_packet_manager_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
using testing::_;
using testing::AnyNumber;
@@ -68,7 +68,7 @@
kDefaultLength, HAS_RETRANSMITTABLE_DATA));
SerializedPacket packet(CreatePacket(packet_number, false));
packet.retransmittable_frames.push_back(
- QuicFrame(QuicStreamFrame(1, false, 0, quiche::QuicheStringPiece())));
+ QuicFrame(QuicStreamFrame(1, false, 0, absl::string_view())));
packet.has_crypto_handshake = IS_HANDSHAKE;
manager_.OnPacketSent(&packet, clock_.Now(), HANDSHAKE_RETRANSMISSION,
HAS_RETRANSMITTABLE_DATA, true);
@@ -252,8 +252,8 @@
PACKET_4BYTE_PACKET_NUMBER, nullptr, kDefaultLength,
false, false);
if (retransmittable) {
- packet.retransmittable_frames.push_back(QuicFrame(
- QuicStreamFrame(kStreamId, false, 0, quiche::QuicheStringPiece())));
+ packet.retransmittable_frames.push_back(
+ QuicFrame(QuicStreamFrame(kStreamId, false, 0, absl::string_view())));
}
return packet;
}
@@ -299,7 +299,7 @@
kDefaultLength, HAS_RETRANSMITTABLE_DATA));
SerializedPacket packet(CreatePacket(packet_number, false));
packet.retransmittable_frames.push_back(
- QuicFrame(QuicStreamFrame(1, false, 0, quiche::QuicheStringPiece())));
+ QuicFrame(QuicStreamFrame(1, false, 0, absl::string_view())));
packet.has_crypto_handshake = IS_HANDSHAKE;
manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
HAS_RETRANSMITTABLE_DATA, true);
@@ -3091,7 +3091,7 @@
}
QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
// Send SHLO.
- QuicStreamFrame crypto_frame(1, false, 0, quiche::QuicheStringPiece());
+ QuicStreamFrame crypto_frame(1, false, 0, absl::string_view());
SendCryptoPacket(1);
// Send data packet.
SendDataPacket(2, ENCRYPTION_FORWARD_SECURE);
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 178ddf3..e28db59 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -8,6 +8,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_connection.h"
#include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
#include "net/third_party/quiche/src/quic/core/quic_flow_controller.h"
@@ -23,7 +24,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_server_stats.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_stack_trace.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
using spdy::SpdyPriority;
@@ -343,7 +343,7 @@
transport_goaway_received_ = true;
}
-void QuicSession::OnMessageReceived(quiche::QuicheStringPiece message) {
+void QuicSession::OnMessageReceived(absl::string_view message) {
QUIC_DVLOG(1) << ENDPOINT << "Received message, length: " << message.length()
<< ", " << message;
}
@@ -2391,13 +2391,13 @@
return stream_id_manager_.max_open_incoming_streams();
}
-std::vector<quiche::QuicheStringPiece>::const_iterator QuicSession::SelectAlpn(
- const std::vector<quiche::QuicheStringPiece>& alpns) const {
+std::vector<absl::string_view>::const_iterator QuicSession::SelectAlpn(
+ const std::vector<absl::string_view>& alpns) const {
const std::string alpn = AlpnForVersion(connection()->version());
return std::find(alpns.cbegin(), alpns.cend(), alpn);
}
-void QuicSession::OnAlpnSelected(quiche::QuicheStringPiece alpn) {
+void QuicSession::OnAlpnSelected(absl::string_view alpn) {
QUIC_DLOG(INFO) << (perspective() == Perspective::IS_SERVER ? "Server: "
: "Client: ")
<< "ALPN selected: " << alpn;
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index e5a0f5c..a3a982b 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -14,6 +14,7 @@
#include <string>
#include <vector>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/handshaker_delegate_interface.h"
#include "net/third_party/quiche/src/quic/core/legacy_quic_stream_id_manager.h"
#include "net/third_party/quiche/src/quic/core/quic_connection.h"
@@ -34,7 +35,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_optional.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -98,7 +98,7 @@
void OnCryptoFrame(const QuicCryptoFrame& frame) override;
void OnRstStream(const QuicRstStreamFrame& frame) override;
void OnGoAway(const QuicGoAwayFrame& frame) override;
- void OnMessageReceived(quiche::QuicheStringPiece message) override;
+ void OnMessageReceived(absl::string_view message) override;
void OnHandshakeDoneReceived() override;
void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
void OnBlockedFrame(const QuicBlockedFrame& frame) override;
@@ -449,12 +449,12 @@
// Provided a list of ALPNs offered by the client, selects an ALPN from the
// list, or alpns.end() if none of the ALPNs are acceptable.
- virtual std::vector<quiche::QuicheStringPiece>::const_iterator SelectAlpn(
- const std::vector<quiche::QuicheStringPiece>& alpns) const;
+ virtual std::vector<absl::string_view>::const_iterator SelectAlpn(
+ const std::vector<absl::string_view>& alpns) const;
// Called when the ALPN of the connection is established for a connection that
// uses TLS handshake.
- virtual void OnAlpnSelected(quiche::QuicheStringPiece alpn);
+ virtual void OnAlpnSelected(absl::string_view alpn);
// Called on clients by the crypto handshaker to provide application state
// necessary for sending application data in 0-RTT. The state provided here is
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 4c611d1..b2c5b1f 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -9,6 +9,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
@@ -40,7 +41,6 @@
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_optional.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
using spdy::kV3HighestPriority;
using spdy::SpdyPriority;
@@ -1561,8 +1561,7 @@
/*is_static*/ true, BIDIRECTIONAL);
QuicSessionPeer::ActivateStream(&session_, std::move(fake_headers_stream));
// Send two bytes of payload.
- QuicStreamFrame data1(headers_stream_id, true, 0,
- quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data1(headers_stream_id, true, 0, absl::string_view("HT"));
EXPECT_CALL(*connection_,
CloseConnection(
QUIC_INVALID_STREAM_ID, "Attempt to close a static stream",
@@ -1574,7 +1573,7 @@
// Send two bytes of payload.
QuicStreamFrame data1(
QuicUtils::GetInvalidStreamId(connection_->transport_version()), true, 0,
- quiche::QuicheStringPiece("HT"));
+ absl::string_view("HT"));
EXPECT_CALL(*connection_,
CloseConnection(
QUIC_INVALID_STREAM_ID, "Received data for an invalid stream",
@@ -1763,7 +1762,7 @@
const QuicStreamOffset kByteOffset = 5678;
std::string body = "hello";
QuicStreamFrame frame(stream->id(), true, kByteOffset,
- quiche::QuicheStringPiece(body));
+ absl::string_view(body));
session_.OnStreamFrame(frame);
QuicStreamOffset total_stream_bytes_sent_by_peer =
@@ -1853,8 +1852,7 @@
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_, OnStreamReset(stream->id(), _));
stream->Reset(QUIC_STREAM_CANCELLED);
- QuicStreamFrame frame(stream->id(), true, kLargeOffset,
- quiche::QuicheStringPiece());
+ QuicStreamFrame frame(stream->id(), true, kLargeOffset, absl::string_view());
session_.OnStreamFrame(frame);
// Check that RST results in connection close.
@@ -1881,7 +1879,7 @@
// FIN or a RST_STREAM from the client.
for (QuicStreamId i = kFirstStreamId; i < kFinalStreamId;
i += QuicUtils::StreamIdDelta(connection_->transport_version())) {
- QuicStreamFrame data1(i, false, 0, quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data1(i, false, 0, absl::string_view("HT"));
session_.OnStreamFrame(data1);
CloseStream(i);
}
@@ -1898,8 +1896,7 @@
.Times(1);
}
// Create one more data streams to exceed limit of open stream.
- QuicStreamFrame data1(kFinalStreamId, false, 0,
- quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data1(kFinalStreamId, false, 0, absl::string_view("HT"));
session_.OnStreamFrame(data1);
}
@@ -1909,7 +1906,7 @@
// protocol point of view).
TestStream* stream = session_.CreateOutgoingBidirectionalStream();
QuicStreamId stream_id = stream->id();
- QuicStreamFrame data1(stream_id, true, 0, quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data1(stream_id, true, 0, absl::string_view("HT"));
session_.OnStreamFrame(data1);
EXPECT_CALL(session_, OnCanCreateNewOutgoingStream(false)).Times(1);
session_.StreamDraining(stream_id, /*unidirectional=*/false);
@@ -1920,11 +1917,11 @@
QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
transport_version(), Perspective::IS_CLIENT);
- QuicStreamFrame data1(stream_id, true, 10, quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data1(stream_id, true, 10, absl::string_view("HT"));
session_.OnStreamFrame(data1);
EXPECT_EQ(1, session_.num_incoming_streams_created());
- QuicStreamFrame data2(stream_id, false, 0, quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data2(stream_id, false, 0, absl::string_view("HT"));
session_.OnStreamFrame(data2);
EXPECT_EQ(1, session_.num_incoming_streams_created());
}
@@ -1937,12 +1934,12 @@
QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
transport_version(), Perspective::IS_CLIENT);
- QuicStreamFrame data1(stream_id, true, 10, quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data1(stream_id, true, 10, absl::string_view("HT"));
session_.OnStreamFrame(data1);
EXPECT_TRUE(QuicSessionPeer::GetPendingStream(&session_, stream_id));
EXPECT_EQ(0, session_.num_incoming_streams_created());
- QuicStreamFrame data2(stream_id, false, 0, quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data2(stream_id, false, 0, absl::string_view("HT"));
session_.OnStreamFrame(data2);
EXPECT_FALSE(QuicSessionPeer::GetPendingStream(&session_, stream_id));
EXPECT_EQ(1, session_.num_incoming_streams_created());
@@ -1956,7 +1953,7 @@
QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
transport_version(), Perspective::IS_CLIENT);
- QuicStreamFrame data1(stream_id, true, 10, quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data1(stream_id, true, 10, absl::string_view("HT"));
session_.OnStreamFrame(data1);
EXPECT_TRUE(QuicSessionPeer::GetPendingStream(&session_, stream_id));
EXPECT_EQ(0, session_.num_incoming_streams_created());
@@ -1969,7 +1966,7 @@
EXPECT_EQ(0, session_.num_incoming_streams_created());
EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(&session_));
- QuicStreamFrame data2(stream_id, false, 0, quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data2(stream_id, false, 0, absl::string_view("HT"));
session_.OnStreamFrame(data2);
EXPECT_FALSE(QuicSessionPeer::GetPendingStream(&session_, stream_id));
EXPECT_EQ(0, session_.num_incoming_streams_created());
@@ -2000,7 +1997,7 @@
session_.set_uses_pending_streams(true);
QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
transport_version(), Perspective::IS_CLIENT);
- QuicStreamFrame data1(stream_id, true, 10, quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data1(stream_id, true, 10, absl::string_view("HT"));
session_.OnStreamFrame(data1);
EXPECT_TRUE(QuicSessionPeer::GetPendingStream(&session_, stream_id));
EXPECT_EQ(0, session_.num_incoming_streams_created());
@@ -2040,7 +2037,7 @@
GetNthClientInitiatedBidirectionalId(2 * kMaxStreams + 1);
for (QuicStreamId i = kFirstStreamId; i < kFinalStreamId;
i += QuicUtils::StreamIdDelta(connection_->transport_version())) {
- QuicStreamFrame data1(i, true, 0, quiche::QuicheStringPiece("HT"));
+ QuicStreamFrame data1(i, true, 0, absl::string_view("HT"));
session_.OnStreamFrame(data1);
EXPECT_EQ(1u, QuicSessionPeer::GetNumOpenDynamicStreams(&session_));
session_.StreamDraining(i, /*unidirectional=*/false);
@@ -2184,7 +2181,7 @@
QuicStreamPeer::CloseReadSide(stream);
// Receive a stream data frame with FIN.
- QuicStreamFrame frame(stream_id, true, 0, quiche::QuicheStringPiece());
+ QuicStreamFrame frame(stream_id, true, 0, absl::string_view());
session_.OnStreamFrame(frame);
EXPECT_TRUE(stream->fin_received());
@@ -2217,7 +2214,7 @@
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(1),
/* fin = */ false, /* offset = */ 0,
- quiche::QuicheStringPiece("foo"));
+ absl::string_view("foo"));
session_.OnStreamFrame(frame);
}
@@ -2540,7 +2537,7 @@
session_.GetMutableCryptoStream()->OnHandshakeMessage(handshake_message);
EXPECT_TRUE(session_.OneRttKeysAvailable());
- quiche::QuicheStringPiece message;
+ absl::string_view message;
EXPECT_CALL(*connection_, SendMessage(1, _, false))
.WillOnce(Return(MESSAGE_STATUS_SUCCESS));
EXPECT_EQ(MessageResult(MESSAGE_STATUS_SUCCESS, 1),
@@ -3043,7 +3040,7 @@
QuicStreamFrame frame(GetNthServerInitiatedBidirectionalId(1),
/* fin = */ false, /* offset = */ 0,
- quiche::QuicheStringPiece("foo"));
+ absl::string_view("foo"));
session_.OnStreamFrame(frame);
}
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 1ad8d37..b6d2cfd 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -7,6 +7,7 @@
#include <limits>
#include <string>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
#include "net/third_party/quiche/src/quic/core/quic_flow_controller.h"
#include "net/third_party/quiche/src/quic/core/quic_session.h"
@@ -18,7 +19,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_optional.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
using quiche::QuicheOptional;
using spdy::SpdyPriority;
@@ -623,7 +623,7 @@
}
void QuicStream::WriteOrBufferData(
- quiche::QuicheStringPiece data,
+ absl::string_view data,
bool fin,
QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
if (data.empty() && !fin) {
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index f0a5a71..70e6e98 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -22,6 +22,7 @@
#include <list>
#include <string>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_flow_controller.h"
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/core/quic_stream_send_buffer.h"
@@ -33,7 +34,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_span.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_optional.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 {
@@ -279,7 +279,7 @@
// If fin is true: if it is immediately passed on to the session,
// write_side_closed() becomes true, otherwise fin_buffered_ becomes true.
void WriteOrBufferData(
- quiche::QuicheStringPiece data,
+ absl::string_view data,
bool fin,
QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
diff --git a/quic/core/quic_stream_send_buffer_test.cc b/quic/core/quic_stream_send_buffer_test.cc
index 6232887..0d5471e 100644
--- a/quic/core/quic_stream_send_buffer_test.cc
+++ b/quic/core/quic_stream_send_buffer_test.cc
@@ -6,6 +6,7 @@
#include <string>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
#include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
@@ -15,13 +16,12 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_test_mem_slice_vector.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_send_buffer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
namespace test {
namespace {
-struct iovec MakeIovec(quiche::QuicheStringPiece data) {
+struct iovec MakeIovec(absl::string_view data) {
struct iovec iov = {const_cast<char*>(data.data()),
static_cast<size_t>(data.size())};
return iov;
@@ -36,8 +36,8 @@
std::string data1(1536, 'a');
std::string data2 = std::string(256, 'b') + std::string(256, 'c');
struct iovec iov[2];
- iov[0] = MakeIovec(quiche::QuicheStringPiece(data1));
- iov[1] = MakeIovec(quiche::QuicheStringPiece(data2));
+ iov[0] = MakeIovec(absl::string_view(data1));
+ iov[1] = MakeIovec(absl::string_view(data2));
QuicUniqueBufferPtr buffer1 = MakeUniqueBuffer(&allocator_, 1024);
memset(buffer1.get(), 'c', 1024);
@@ -88,23 +88,23 @@
std::string copy4(768, 'd');
ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer));
- EXPECT_EQ(copy1, quiche::QuicheStringPiece(buf, 1024));
+ EXPECT_EQ(copy1, absl::string_view(buf, 1024));
ASSERT_TRUE(send_buffer_.WriteStreamData(1024, 1024, &writer));
- EXPECT_EQ(copy2, quiche::QuicheStringPiece(buf + 1024, 1024));
+ EXPECT_EQ(copy2, absl::string_view(buf + 1024, 1024));
ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 1024, &writer));
- EXPECT_EQ(copy3, quiche::QuicheStringPiece(buf + 2048, 1024));
+ EXPECT_EQ(copy3, absl::string_view(buf + 2048, 1024));
ASSERT_TRUE(send_buffer_.WriteStreamData(3072, 768, &writer));
- EXPECT_EQ(copy4, quiche::QuicheStringPiece(buf + 3072, 768));
+ EXPECT_EQ(copy4, absl::string_view(buf + 3072, 768));
// Test data piece across boundries.
QuicDataWriter writer2(4000, buf, quiche::HOST_BYTE_ORDER);
std::string copy5 =
std::string(536, 'a') + std::string(256, 'b') + std::string(232, 'c');
ASSERT_TRUE(send_buffer_.WriteStreamData(1000, 1024, &writer2));
- EXPECT_EQ(copy5, quiche::QuicheStringPiece(buf, 1024));
+ EXPECT_EQ(copy5, absl::string_view(buf, 1024));
ASSERT_TRUE(send_buffer_.WriteStreamData(2500, 1024, &writer2));
std::string copy6 = std::string(572, 'c') + std::string(452, 'd');
- EXPECT_EQ(copy6, quiche::QuicheStringPiece(buf + 1024, 1024));
+ EXPECT_EQ(copy6, absl::string_view(buf + 1024, 1024));
// Invalid data copy.
QuicDataWriter writer3(4000, buf, quiche::HOST_BYTE_ORDER);
@@ -129,21 +129,20 @@
// Write more than one slice.
EXPECT_EQ(0, QuicStreamSendBufferPeer::write_index(&send_buffer_));
ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer));
- EXPECT_EQ(copy1, quiche::QuicheStringPiece(buf, 1024));
+ EXPECT_EQ(copy1, absl::string_view(buf, 1024));
EXPECT_EQ(1, QuicStreamSendBufferPeer::write_index(&send_buffer_));
// Retransmit the first frame and also send new data.
ASSERT_TRUE(send_buffer_.WriteStreamData(0, 2048, &writer));
- EXPECT_EQ(copy1 + copy2, quiche::QuicheStringPiece(buf + 1024, 2048));
+ EXPECT_EQ(copy1 + copy2, absl::string_view(buf + 1024, 2048));
// Write new data.
EXPECT_EQ(2048u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 50, &writer));
- EXPECT_EQ(std::string(50, 'c'),
- quiche::QuicheStringPiece(buf + 1024 + 2048, 50));
+ EXPECT_EQ(std::string(50, 'c'), absl::string_view(buf + 1024 + 2048, 50));
EXPECT_EQ(3072u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 1124, &writer));
- EXPECT_EQ(copy3, quiche::QuicheStringPiece(buf + 1024 + 2048 + 50, 1124));
+ EXPECT_EQ(copy3, absl::string_view(buf + 1024 + 2048 + 50, 1124));
EXPECT_EQ(3840u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
}
diff --git a/quic/core/quic_stream_sequencer.cc b/quic/core/quic_stream_sequencer.cc
index 0dfc8f7..7d1c237 100644
--- a/quic/core/quic_stream_sequencer.cc
+++ b/quic/core/quic_stream_sequencer.cc
@@ -10,6 +10,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_clock.h"
#include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
@@ -22,7 +23,6 @@
#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/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -65,8 +65,8 @@
size_t bytes_written;
std::string error_details;
QuicErrorCode result = buffered_frames_.OnStreamData(
- byte_offset, quiche::QuicheStringPiece(data_buffer, data_len),
- &bytes_written, &error_details);
+ byte_offset, absl::string_view(data_buffer, data_len), &bytes_written,
+ &error_details);
if (result != QUIC_NO_ERROR) {
std::string details = quiche::QuicheStrCat("Stream ", stream_->id(), ": ",
QuicErrorCodeToString(result),
diff --git a/quic/core/quic_stream_sequencer_buffer.cc b/quic/core/quic_stream_sequencer_buffer.cc
index 8a26521..b4143ef 100644
--- a/quic/core/quic_stream_sequencer_buffer.cc
+++ b/quic/core/quic_stream_sequencer_buffer.cc
@@ -6,6 +6,7 @@
#include <string>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_constants.h"
#include "net/third_party/quiche/src/quic/core/quic_interval.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
@@ -13,7 +14,6 @@
#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/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
namespace {
@@ -68,7 +68,7 @@
QuicErrorCode QuicStreamSequencerBuffer::OnStreamData(
QuicStreamOffset starting_offset,
- quiche::QuicheStringPiece data,
+ absl::string_view data,
size_t* const bytes_buffered,
std::string* error_details) {
*bytes_buffered = 0;
@@ -135,7 +135,7 @@
}
bool QuicStreamSequencerBuffer::CopyStreamData(QuicStreamOffset offset,
- quiche::QuicheStringPiece data,
+ absl::string_view data,
size_t* bytes_copy,
std::string* error_details) {
*bytes_copy = 0;
diff --git a/quic/core/quic_stream_sequencer_buffer.h b/quic/core/quic_stream_sequencer_buffer.h
index 0ad9841..98ffa9c 100644
--- a/quic/core/quic_stream_sequencer_buffer.h
+++ b/quic/core/quic_stream_sequencer_buffer.h
@@ -28,11 +28,11 @@
// Expected Use:
// QuicStreamSequencerBuffer buffer(2.5 * 8 * 1024);
// std::string source(1024, 'a');
-// quiche::QuicheStringPiece string_piece(source.data(), source.size());
+// absl::string_view string_piece(source.data(), source.size());
// size_t written = 0;
// buffer.OnStreamData(800, string_piece, GetEpollClockNow(), &written);
// source = std::string{800, 'b'};
-// quiche::QuicheStringPiece string_piece1(source.data(), 800);
+// absl::string_view string_piece1(source.data(), 800);
// // Try to write to [1, 801), but should fail due to overlapping,
// // res should be QUIC_INVALID_STREAM_DATA
// auto res = buffer.OnStreamData(1, string_piece1, &written));
@@ -64,12 +64,12 @@
#include <memory>
#include <string>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_interval_set.h"
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_iovec.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -107,7 +107,7 @@
// successfully buffered, returns QUIC_NO_ERROR and stores the number of
// bytes buffered in |bytes_buffered|. Returns an error otherwise.
QuicErrorCode OnStreamData(QuicStreamOffset offset,
- quiche::QuicheStringPiece data,
+ absl::string_view data,
size_t* bytes_buffered,
std::string* error_details);
@@ -168,7 +168,7 @@
// Copies |data| to blocks_, sets |bytes_copy|. Returns true if the copy is
// successful. Otherwise, sets |error_details| and returns false.
bool CopyStreamData(QuicStreamOffset offset,
- quiche::QuicheStringPiece data,
+ absl::string_view data,
size_t* bytes_copy,
std::string* error_details);
diff --git a/quic/core/quic_stream_sequencer_buffer_test.cc b/quic/core/quic_stream_sequencer_buffer_test.cc
index 7341983..f12810b 100644
--- a/quic/core/quic_stream_sequencer_buffer_test.cc
+++ b/quic/core/quic_stream_sequencer_buffer_test.cc
@@ -11,20 +11,20 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_sequencer_buffer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
namespace test {
-quiche::QuicheStringPiece IovecToStringPiece(iovec iov) {
- return quiche::QuicheStringPiece(reinterpret_cast<const char*>(iov.iov_base),
- iov.iov_len);
+absl::string_view IovecToStringPiece(iovec iov) {
+ return absl::string_view(reinterpret_cast<const char*>(iov.iov_base),
+ iov.iov_len);
}
char GetCharFromIOVecs(size_t offset, iovec iov[], size_t count) {
@@ -159,8 +159,8 @@
TEST_F(QuicStreamSequencerBufferTest, OnStreamDataInvalidSource) {
// Pass in an invalid source, expects to return error.
- quiche::QuicheStringPiece source;
- source = quiche::QuicheStringPiece(nullptr, 1024);
+ absl::string_view source;
+ source = absl::string_view(nullptr, 1024);
EXPECT_THAT(buffer_->OnStreamData(800, source, &written_, &error_details_),
IsError(QUIC_STREAM_SEQUENCER_INVALID_STATE));
EXPECT_EQ(0u, error_details_.find(quiche::QuicheStrCat(
@@ -320,7 +320,7 @@
QUIC_LOG(ERROR) << error_details_;
EXPECT_EQ(100u, read);
EXPECT_EQ(100u, buffer_->BytesConsumed());
- EXPECT_EQ(source, quiche::QuicheStringPiece(dest, read));
+ EXPECT_EQ(source, absl::string_view(dest, read));
// The first block should be released as its data has been read out.
EXPECT_EQ(nullptr, helper_->GetBlock(0));
EXPECT_TRUE(helper_->CheckBufferInvariants());
@@ -610,8 +610,7 @@
// Peek at a different offset.
EXPECT_TRUE(buffer_->PeekRegion(100, &iov));
- EXPECT_EQ(quiche::QuicheStringPiece(source).substr(100),
- IovecToStringPiece(iov));
+ EXPECT_EQ(absl::string_view(source).substr(100), IovecToStringPiece(iov));
// Peeking at or after FirstMissingByte() returns false.
EXPECT_FALSE(buffer_->PeekRegion(kBlockSizeBytes, &iov));
@@ -638,15 +637,15 @@
// Peek with an offset inside the first write.
const QuicStreamOffset offset1 = 500;
EXPECT_TRUE(buffer_->PeekRegion(offset1, &iov));
- EXPECT_EQ(quiche::QuicheStringPiece(source1).substr(offset1),
+ EXPECT_EQ(absl::string_view(source1).substr(offset1),
IovecToStringPiece(iov).substr(0, length1 - offset1));
- EXPECT_EQ(quiche::QuicheStringPiece(source2),
+ EXPECT_EQ(absl::string_view(source2),
IovecToStringPiece(iov).substr(length1 - offset1));
// Peek with an offset inside the second write.
const QuicStreamOffset offset2 = 1500;
EXPECT_TRUE(buffer_->PeekRegion(offset2, &iov));
- EXPECT_EQ(quiche::QuicheStringPiece(source2).substr(offset2 - length1),
+ EXPECT_EQ(absl::string_view(source2).substr(offset2 - length1),
IovecToStringPiece(iov));
// Peeking at or after FirstMissingByte() returns false.
@@ -671,19 +670,16 @@
EXPECT_TRUE(buffer_->PeekRegion(0, &iov));
EXPECT_EQ(kBlockSizeBytes, iov.iov_len);
EXPECT_EQ(source1, IovecToStringPiece(iov).substr(0, length1));
- EXPECT_EQ(
- quiche::QuicheStringPiece(source2).substr(0, kBlockSizeBytes - length1),
- IovecToStringPiece(iov).substr(length1));
+ EXPECT_EQ(absl::string_view(source2).substr(0, kBlockSizeBytes - length1),
+ IovecToStringPiece(iov).substr(length1));
EXPECT_TRUE(buffer_->PeekRegion(length1, &iov));
- EXPECT_EQ(
- quiche::QuicheStringPiece(source2).substr(0, kBlockSizeBytes - length1),
- IovecToStringPiece(iov));
+ EXPECT_EQ(absl::string_view(source2).substr(0, kBlockSizeBytes - length1),
+ IovecToStringPiece(iov));
EXPECT_TRUE(buffer_->PeekRegion(kBlockSizeBytes, &iov));
- EXPECT_EQ(
- quiche::QuicheStringPiece(source2).substr(kBlockSizeBytes - length1),
- IovecToStringPiece(iov));
+ EXPECT_EQ(absl::string_view(source2).substr(kBlockSizeBytes - length1),
+ IovecToStringPiece(iov));
// Peeking at or after FirstMissingByte() returns false.
EXPECT_FALSE(buffer_->PeekRegion(length1 + length2, &iov));
@@ -706,12 +702,10 @@
EXPECT_FALSE(buffer_->PeekRegion(512, &iov));
EXPECT_TRUE(buffer_->PeekRegion(1024, &iov));
- EXPECT_EQ(quiche::QuicheStringPiece(source1).substr(1024),
- IovecToStringPiece(iov));
+ EXPECT_EQ(absl::string_view(source1).substr(1024), IovecToStringPiece(iov));
EXPECT_TRUE(buffer_->PeekRegion(1500, &iov));
- EXPECT_EQ(quiche::QuicheStringPiece(source1).substr(1500),
- IovecToStringPiece(iov));
+ EXPECT_EQ(absl::string_view(source1).substr(1500), IovecToStringPiece(iov));
// Consume rest of block.
EXPECT_TRUE(buffer_->MarkConsumed(kBlockSizeBytes - 1024));
@@ -725,8 +719,7 @@
EXPECT_EQ(source2, IovecToStringPiece(iov));
EXPECT_TRUE(buffer_->PeekRegion(kBlockSizeBytes + 128, &iov));
- EXPECT_EQ(quiche::QuicheStringPiece(source2).substr(128),
- IovecToStringPiece(iov));
+ EXPECT_EQ(absl::string_view(source2).substr(128), IovecToStringPiece(iov));
// Peeking into consumed data still fails.
EXPECT_FALSE(buffer_->PeekRegion(0, &iov));
@@ -933,7 +926,7 @@
for (size_t i = 0; i < num_to_write; ++i) {
write_buf[i] = (offset + i) % 256;
}
- quiche::QuicheStringPiece string_piece_w(write_buf.get(), num_to_write);
+ absl::string_view string_piece_w(write_buf.get(), num_to_write);
auto result = buffer_->OnStreamData(offset, string_piece_w, &written_,
&error_details_);
if (result == QUIC_NO_ERROR) {
diff --git a/quic/core/quic_stream_sequencer_test.cc b/quic/core/quic_stream_sequencer_test.cc
index bdf1412..cd39fcd 100644
--- a/quic/core/quic_stream_sequencer_test.cc
+++ b/quic/core/quic_stream_sequencer_test.cc
@@ -11,6 +11,7 @@
#include <utility>
#include <vector>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_stream.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
@@ -20,7 +21,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_sequencer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
using testing::_;
using testing::AnyNumber;
@@ -116,7 +116,7 @@
return true;
}
- bool VerifyIovec(const iovec& iovec, quiche::QuicheStringPiece expected) {
+ bool VerifyIovec(const iovec& iovec, absl::string_view expected) {
if (iovec.iov_len != expected.length()) {
QUIC_LOG(ERROR) << "Invalid length: " << iovec.iov_len << " vs "
<< expected.length();
@@ -600,10 +600,10 @@
// overlapping byte ranges - if they do, we close the connection.
QuicStreamId id = 1;
- QuicStreamFrame frame1(id, false, 1, quiche::QuicheStringPiece("hello"));
+ QuicStreamFrame frame1(id, false, 1, absl::string_view("hello"));
sequencer_->OnStreamFrame(frame1);
- QuicStreamFrame frame2(id, false, 2, quiche::QuicheStringPiece("hello"));
+ QuicStreamFrame frame2(id, false, 2, absl::string_view("hello"));
EXPECT_CALL(stream_, OnUnrecoverableError(QUIC_OVERLAPPING_STREAM_DATA, _))
.Times(0);
sequencer_->OnStreamFrame(frame2);
@@ -635,7 +635,7 @@
EXPECT_EQ(0u, sequencer_->NumBytesBuffered());
// Received [1498, 1503).
- QuicStreamFrame frame3(id, false, 1498, quiche::QuicheStringPiece("hello"));
+ QuicStreamFrame frame3(id, false, 1498, absl::string_view("hello"));
EXPECT_CALL(stream_, OnDataAvailable());
sequencer_->OnStreamFrame(frame3);
EXPECT_CALL(stream_, AddBytesConsumed(3));
@@ -644,7 +644,7 @@
EXPECT_EQ(0u, sequencer_->NumBytesBuffered());
// Received [1000, 1005).
- QuicStreamFrame frame4(id, false, 1000, quiche::QuicheStringPiece("hello"));
+ QuicStreamFrame frame4(id, false, 1000, absl::string_view("hello"));
EXPECT_CALL(stream_, OnDataAvailable()).Times(0);
sequencer_->OnStreamFrame(frame4);
EXPECT_EQ(1503u, sequencer_->NumBytesConsumed());
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index f2b5563..77b548a 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_rst_stream_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_connection.h"
#include "net/third_party/quiche/src/quic/core/quic_constants.h"
@@ -32,7 +33,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_optional.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
using testing::_;
using testing::AnyNumber;
@@ -295,8 +295,7 @@
// Write no data and no fin. If we consume nothing we should not be write
// blocked.
EXPECT_QUIC_BUG(
- stream_->WriteOrBufferData(quiche::QuicheStringPiece(), false, nullptr),
- "");
+ stream_->WriteOrBufferData(absl::string_view(), false, nullptr), "");
EXPECT_FALSE(HasWriteBlockedStreams());
}
@@ -310,8 +309,7 @@
return session_->ConsumeData(stream_->id(), 1u, 0u, NO_FIN,
NOT_RETRANSMISSION, QUICHE_NULLOPT);
}));
- stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), false,
- nullptr);
+ stream_->WriteOrBufferData(absl::string_view(kData1, 2), false, nullptr);
EXPECT_TRUE(session_->HasUnackedStreamData());
ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
EXPECT_EQ(1u, stream_->BufferedDataBytes());
@@ -329,8 +327,7 @@
return session_->ConsumeData(stream_->id(), 2u, 0u, NO_FIN,
NOT_RETRANSMISSION, QUICHE_NULLOPT);
}));
- stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), true,
- nullptr);
+ stream_->WriteOrBufferData(absl::string_view(kData1, 2), true, nullptr);
EXPECT_TRUE(session_->HasUnackedStreamData());
ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
}
@@ -342,7 +339,7 @@
// as the fin was not consumed.
EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
.WillOnce(Return(QuicConsumedData(0, false)));
- stream_->WriteOrBufferData(quiche::QuicheStringPiece(), true, nullptr);
+ stream_->WriteOrBufferData(absl::string_view(), true, nullptr);
ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
}
@@ -354,8 +351,7 @@
// crash with an unknown stream.
EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
.WillOnce(Invoke(this, &QuicStreamTest::CloseStreamOnWriteError));
- stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), false,
- nullptr);
+ stream_->WriteOrBufferData(absl::string_view(kData1, 2), false, nullptr);
ASSERT_EQ(0u, write_blocked_list_->NumBlockedStreams());
}
@@ -452,8 +448,7 @@
return session_->ConsumeData(stream_->id(), 1u, 0u, NO_FIN,
NOT_RETRANSMISSION, QUICHE_NULLOPT);
}));
- stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 1), false,
- nullptr);
+ stream_->WriteOrBufferData(absl::string_view(kData1, 1), false, nullptr);
EXPECT_TRUE(session_->HasUnackedStreamData());
EXPECT_FALSE(fin_sent());
EXPECT_FALSE(rst_sent());
@@ -482,8 +477,7 @@
return session_->ConsumeData(stream_->id(), 1u, 0u, FIN,
NOT_RETRANSMISSION, QUICHE_NULLOPT);
}));
- stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 1), true,
- nullptr);
+ stream_->WriteOrBufferData(absl::string_view(kData1, 1), true, nullptr);
EXPECT_TRUE(fin_sent());
EXPECT_FALSE(rst_sent());
@@ -673,7 +667,7 @@
current_connection_flow_control_offset);
QuicStreamFrame zero_length_stream_frame_with_fin(
stream_->id(), /*fin=*/true, kByteOffsetExceedingFlowControlWindow,
- quiche::QuicheStringPiece());
+ absl::string_view());
EXPECT_EQ(0, zero_length_stream_frame_with_fin.data_length);
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
@@ -746,8 +740,7 @@
return session_->ConsumeData(stream_->id(), 2u, 0u, FIN,
NOT_RETRANSMISSION, QUICHE_NULLOPT);
}));
- stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), true,
- nullptr);
+ stream_->WriteOrBufferData(absl::string_view(kData1, 2), true, nullptr);
EXPECT_TRUE(stream_->write_side_closed());
EXPECT_EQ(1u, QuicSessionPeer::GetNumDrainingStreams(session_.get()));
@@ -764,8 +757,7 @@
return session_->ConsumeData(stream_->id(), 2u, 0u, FIN,
NOT_RETRANSMISSION, QUICHE_NULLOPT);
}));
- stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), true,
- nullptr);
+ stream_->WriteOrBufferData(absl::string_view(kData1, 2), true, nullptr);
EXPECT_TRUE(stream_->write_side_closed());
EXPECT_EQ(1u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
diff --git a/quic/core/quic_tag.cc b/quic/core/quic_tag.cc
index d6c2f6c..7cc25e0 100644
--- a/quic/core/quic_tag.cc
+++ b/quic/core/quic_tag.cc
@@ -74,7 +74,7 @@
tag_vector.end();
}
-QuicTag ParseQuicTag(quiche::QuicheStringPiece tag_string) {
+QuicTag ParseQuicTag(absl::string_view tag_string) {
quiche::QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&tag_string);
std::string tag_bytes;
if (tag_string.length() == 8) {
@@ -92,13 +92,13 @@
return tag;
}
-QuicTagVector ParseQuicTagVector(quiche::QuicheStringPiece tags_string) {
+QuicTagVector ParseQuicTagVector(absl::string_view tags_string) {
QuicTagVector tag_vector;
quiche::QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&tags_string);
if (!tags_string.empty()) {
- std::vector<quiche::QuicheStringPiece> tag_strings =
+ std::vector<absl::string_view> tag_strings =
quiche::QuicheTextUtils::Split(tags_string, ',');
- for (quiche::QuicheStringPiece tag_string : tag_strings) {
+ for (absl::string_view tag_string : tag_strings) {
tag_vector.push_back(ParseQuicTag(tag_string));
}
}
diff --git a/quic/core/quic_tag.h b/quic/core/quic_tag.h
index 7ba6cfc..8b68e33 100644
--- a/quic/core/quic_tag.h
+++ b/quic/core/quic_tag.h
@@ -9,8 +9,8 @@
#include <string>
#include <vector>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -53,12 +53,12 @@
// corresponding QuicTag. Note that tags that are less than four characters
// long are right-padded with zeroes. Tags that contain non-ASCII characters
// are represented as 8-character-long hexadecimal strings.
-QUIC_EXPORT_PRIVATE QuicTag ParseQuicTag(quiche::QuicheStringPiece tag_string);
+QUIC_EXPORT_PRIVATE QuicTag ParseQuicTag(absl::string_view tag_string);
// Utility function that converts a string of the form "ABCD,EFGH" to a vector
// of the form {kABCD,kEFGH}. Note the caveats on ParseQuicTag.
QUIC_EXPORT_PRIVATE QuicTagVector
-ParseQuicTagVector(quiche::QuicheStringPiece tags_string);
+ParseQuicTagVector(absl::string_view tags_string);
} // namespace quic
diff --git a/quic/core/quic_time_wait_list_manager.cc b/quic/core/quic_time_wait_list_manager.cc
index a09caac..769a9c5 100644
--- a/quic/core/quic_time_wait_list_manager.cc
+++ b/quic/core/quic_time_wait_list_manager.cc
@@ -9,6 +9,7 @@
#include <memory>
#include <utility>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
@@ -22,7 +23,6 @@
#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_socket_address.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 {
@@ -239,7 +239,7 @@
<< (ietf_quic ? "" : "!") << "ietf_quic, "
<< (use_length_prefix ? "" : "!")
<< "use_length_prefix:" << std::endl
- << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
+ << quiche::QuicheTextUtils::HexDump(absl::string_view(
version_packet->data(), version_packet->length()));
SendOrQueuePacket(std::make_unique<QueuedPacket>(self_address, peer_address,
std::move(version_packet)),
@@ -263,9 +263,9 @@
BuildIetfStatelessResetPacket(connection_id);
QUIC_DVLOG(2) << "Dispatcher sending IETF reset packet for "
<< connection_id << std::endl
- << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
- ietf_reset_packet->data(),
- ietf_reset_packet->length()));
+ << quiche::QuicheTextUtils::HexDump(
+ absl::string_view(ietf_reset_packet->data(),
+ ietf_reset_packet->length()));
SendOrQueuePacket(
std::make_unique<QueuedPacket>(self_address, peer_address,
std::move(ietf_reset_packet)),
@@ -283,7 +283,7 @@
std::unique_ptr<QuicEncryptedPacket> reset_packet = BuildPublicReset(packet);
QUIC_DVLOG(2) << "Dispatcher sending reset packet for " << connection_id
<< std::endl
- << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
+ << quiche::QuicheTextUtils::HexDump(absl::string_view(
reset_packet->data(), reset_packet->length()));
SendOrQueuePacket(std::make_unique<QueuedPacket>(self_address, peer_address,
std::move(reset_packet)),
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index b6619d4..2e1562f 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -9,6 +9,7 @@
#include <cstring>
#include <string>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
#include "net/third_party/quiche/src/quic/core/quic_constants.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -21,7 +22,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
namespace {
@@ -36,8 +36,7 @@
#endif
#ifdef QUIC_UTIL_HAS_UINT128
-QuicUint128 IncrementalHashFast(QuicUint128 uhash,
- quiche::QuicheStringPiece data) {
+QuicUint128 IncrementalHashFast(QuicUint128 uhash, absl::string_view data) {
// This code ends up faster than the naive implementation for 2 reasons:
// 1. QuicUint128 is sufficiently complicated that the compiler
// cannot transform the multiplication by kPrime into a shift-multiply-add;
@@ -60,8 +59,7 @@
#ifndef QUIC_UTIL_HAS_UINT128
// Slow implementation of IncrementalHash. In practice, only used by Chromium.
-QuicUint128 IncrementalHashSlow(QuicUint128 hash,
- quiche::QuicheStringPiece data) {
+QuicUint128 IncrementalHashSlow(QuicUint128 hash, absl::string_view data) {
// kPrime = 309485009821345068724781371
static const QuicUint128 kPrime = MakeQuicUint128(16777216, 315);
const uint8_t* octets = reinterpret_cast<const uint8_t*>(data.data());
@@ -73,7 +71,7 @@
}
#endif
-QuicUint128 IncrementalHash(QuicUint128 hash, quiche::QuicheStringPiece data) {
+QuicUint128 IncrementalHash(QuicUint128 hash, absl::string_view data) {
#ifdef QUIC_UTIL_HAS_UINT128
return IncrementalHashFast(hash, data);
#else
@@ -84,7 +82,7 @@
} // namespace
// static
-uint64_t QuicUtils::FNV1a_64_Hash(quiche::QuicheStringPiece data) {
+uint64_t QuicUtils::FNV1a_64_Hash(absl::string_view data) {
static const uint64_t kOffset = UINT64_C(14695981039346656037);
static const uint64_t kPrime = UINT64_C(1099511628211);
@@ -101,21 +99,20 @@
}
// static
-QuicUint128 QuicUtils::FNV1a_128_Hash(quiche::QuicheStringPiece data) {
- return FNV1a_128_Hash_Three(data, quiche::QuicheStringPiece(),
- quiche::QuicheStringPiece());
+QuicUint128 QuicUtils::FNV1a_128_Hash(absl::string_view data) {
+ return FNV1a_128_Hash_Three(data, absl::string_view(), absl::string_view());
}
// static
-QuicUint128 QuicUtils::FNV1a_128_Hash_Two(quiche::QuicheStringPiece data1,
- quiche::QuicheStringPiece data2) {
- return FNV1a_128_Hash_Three(data1, data2, quiche::QuicheStringPiece());
+QuicUint128 QuicUtils::FNV1a_128_Hash_Two(absl::string_view data1,
+ absl::string_view data2) {
+ return FNV1a_128_Hash_Three(data1, data2, absl::string_view());
}
// static
-QuicUint128 QuicUtils::FNV1a_128_Hash_Three(quiche::QuicheStringPiece data1,
- quiche::QuicheStringPiece data2,
- quiche::QuicheStringPiece data3) {
+QuicUint128 QuicUtils::FNV1a_128_Hash_Three(absl::string_view data1,
+ absl::string_view data2,
+ absl::string_view data3) {
// The two constants are defined as part of the hash algorithm.
// see http://www.isthe.com/chongo/tech/comp/fnv/
// kOffset = 144066263297769815596495629667062367629
@@ -287,7 +284,7 @@
}
// static
-struct iovec QuicUtils::MakeIovec(quiche::QuicheStringPiece data) {
+struct iovec QuicUtils::MakeIovec(absl::string_view data) {
struct iovec iov = {const_cast<char*>(data.data()),
static_cast<size_t>(data.size())};
return iov;
@@ -511,7 +508,7 @@
return EmptyQuicConnectionId();
}
const uint64_t connection_id_hash64 = FNV1a_64_Hash(
- quiche::QuicheStringPiece(connection_id.data(), connection_id.length()));
+ absl::string_view(connection_id.data(), connection_id.length()));
if (expected_connection_id_length <= sizeof(uint64_t)) {
return QuicConnectionId(
reinterpret_cast<const char*>(&connection_id_hash64),
@@ -519,7 +516,7 @@
}
char new_connection_id_data[255] = {};
const QuicUint128 connection_id_hash128 = FNV1a_128_Hash(
- quiche::QuicheStringPiece(connection_id.data(), connection_id.length()));
+ absl::string_view(connection_id.data(), connection_id.length()));
static_assert(sizeof(connection_id_hash64) + sizeof(connection_id_hash128) <=
sizeof(new_connection_id_data),
"bad size");
@@ -615,7 +612,7 @@
QuicUint128 QuicUtils::GenerateStatelessResetToken(
QuicConnectionId connection_id) {
return FNV1a_128_Hash(
- quiche::QuicheStringPiece(connection_id.data(), connection_id.length()));
+ absl::string_view(connection_id.data(), connection_id.length()));
}
// static
diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h
index 05c7124..c6f5ca0 100644
--- a/quic/core/quic_utils.h
+++ b/quic/core/quic_utils.h
@@ -11,6 +11,7 @@
#include <string>
#include <type_traits>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
@@ -21,7 +22,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_iovec.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -31,22 +31,22 @@
// Returns the 64 bit FNV1a hash of the data. See
// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
- static uint64_t FNV1a_64_Hash(quiche::QuicheStringPiece data);
+ static uint64_t FNV1a_64_Hash(absl::string_view data);
// Returns the 128 bit FNV1a hash of the data. See
// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
- static QuicUint128 FNV1a_128_Hash(quiche::QuicheStringPiece data);
+ static QuicUint128 FNV1a_128_Hash(absl::string_view data);
// Returns the 128 bit FNV1a hash of the two sequences of data. See
// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
- static QuicUint128 FNV1a_128_Hash_Two(quiche::QuicheStringPiece data1,
- quiche::QuicheStringPiece data2);
+ static QuicUint128 FNV1a_128_Hash_Two(absl::string_view data1,
+ absl::string_view data2);
// Returns the 128 bit FNV1a hash of the three sequences of data. See
// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
- static QuicUint128 FNV1a_128_Hash_Three(quiche::QuicheStringPiece data1,
- quiche::QuicheStringPiece data2,
- quiche::QuicheStringPiece data3);
+ static QuicUint128 FNV1a_128_Hash_Three(absl::string_view data1,
+ absl::string_view data2,
+ absl::string_view data3);
// SerializeUint128 writes the first 96 bits of |v| in little-endian form
// to |out|.
@@ -80,7 +80,7 @@
char* buffer);
// Creates an iovec pointing to the same data as |data|.
- static struct iovec MakeIovec(quiche::QuicheStringPiece data);
+ static struct iovec MakeIovec(absl::string_view data);
// Returns the opposite Perspective of the |perspective| passed in.
static constexpr Perspective InvertPerspective(Perspective perspective) {
diff --git a/quic/core/quic_utils_test.cc b/quic/core/quic_utils_test.cc
index 041cd98..b3b8457 100644
--- a/quic/core/quic_utils_test.cc
+++ b/quic/core/quic_utils_test.cc
@@ -6,12 +6,12 @@
#include <string>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
namespace test {
@@ -100,7 +100,7 @@
data[i] = i % 255;
}
EXPECT_EQ(IncrementalHashReference(data.data(), data.size()),
- QuicUtils::FNV1a_128_Hash(quiche::QuicheStringPiece(
+ QuicUtils::FNV1a_128_Hash(absl::string_view(
reinterpret_cast<const char*>(data.data()), data.size())));
}
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index d3f707b..745957f 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -328,8 +328,7 @@
return UnsupportedQuicVersion();
}
-ParsedQuicVersion ParseQuicVersionString(
- quiche::QuicheStringPiece version_string) {
+ParsedQuicVersion ParseQuicVersionString(absl::string_view version_string) {
if (version_string.empty()) {
return UnsupportedQuicVersion();
}
@@ -374,11 +373,11 @@
}
ParsedQuicVersionVector ParseQuicVersionVectorString(
- quiche::QuicheStringPiece versions_string) {
+ absl::string_view versions_string) {
ParsedQuicVersionVector versions;
- std::vector<quiche::QuicheStringPiece> version_strings =
+ std::vector<absl::string_view> version_strings =
quiche::QuicheTextUtils::Split(versions_string, ',');
- for (quiche::QuicheStringPiece version_string : version_strings) {
+ for (absl::string_view version_string : version_strings) {
quiche::QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(
&version_string);
ParsedQuicVersion version = ParseQuicVersionString(version_string);
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index e983272..c29b715 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -26,10 +26,10 @@
#include <string>
#include <vector>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_tag.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -497,13 +497,13 @@
// ALPN such as "h3-29" or "h3-Q050". For PROTOCOL_QUIC_CRYPTO versions, also
// supports parsing numbers such as "46".
QUIC_EXPORT_PRIVATE ParsedQuicVersion
-ParseQuicVersionString(quiche::QuicheStringPiece version_string);
+ParseQuicVersionString(absl::string_view version_string);
// Parses a comma-separated list of QUIC version strings. Supports parsing by
// label, ALPN and numbers for PROTOCOL_QUIC_CRYPTO. Skips unknown versions.
// For example: "h3-29,Q050,46".
QUIC_EXPORT_PRIVATE ParsedQuicVersionVector
-ParseQuicVersionVectorString(quiche::QuicheStringPiece versions_string);
+ParseQuicVersionVectorString(absl::string_view versions_string);
// Constructs a QuicVersionLabel from the provided ParsedQuicVersion.
QUIC_EXPORT_PRIVATE QuicVersionLabel
diff --git a/quic/core/tls_chlo_extractor.cc b/quic/core/tls_chlo_extractor.cc
index 7c10d2c..06ed1c8 100644
--- a/quic/core/tls_chlo_extractor.cc
+++ b/quic/core/tls_chlo_extractor.cc
@@ -6,6 +6,7 @@
#include <cstring>
#include <memory>
+#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_crypto_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
@@ -16,7 +17,6 @@
#include "net/third_party/quiche/src/quic/core/quic_versions.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
@@ -280,14 +280,14 @@
if (rv == 1) {
QuicDataReader alpns_reader(reinterpret_cast<const char*>(alpn_data),
alpn_len);
- quiche::QuicheStringPiece alpns_payload;
+ absl::string_view alpns_payload;
if (!alpns_reader.ReadStringPiece16(&alpns_payload)) {
HandleUnrecoverableError("Failed to read alpns_payload");
return;
}
QuicDataReader alpns_payload_reader(alpns_payload);
while (!alpns_payload_reader.IsDoneReading()) {
- quiche::QuicheStringPiece alpn_payload;
+ absl::string_view alpn_payload;
if (!alpns_payload_reader.ReadStringPiece8(&alpn_payload)) {
HandleUnrecoverableError("Failed to read alpn_payload");
return;
diff --git a/quic/core/tls_chlo_extractor.h b/quic/core/tls_chlo_extractor.h
index b50d2e2..53e06b4 100644
--- a/quic/core/tls_chlo_extractor.h
+++ b/quic/core/tls_chlo_extractor.h
@@ -67,10 +67,9 @@
const QuicVersionNegotiationPacket& /*packet*/) override {}
void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
QuicConnectionId /*new_connection_id*/,
- quiche::QuicheStringPiece /*retry_token*/,
- quiche::QuicheStringPiece /*retry_integrity_tag*/,
- quiche::QuicheStringPiece /*retry_without_tag*/) override {
- }
+ absl::string_view /*retry_token*/,
+ absl::string_view /*retry_integrity_tag*/,
+ absl::string_view /*retry_without_tag*/) override {}
bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override;
bool OnUnauthenticatedHeader(const QuicPacketHeader& /*header*/) override {
return true;
diff --git a/quic/core/tls_chlo_extractor_test.cc b/quic/core/tls_chlo_extractor_test.cc
index 955e58c..db926b4 100644
--- a/quic/core/tls_chlo_extractor_test.cc
+++ b/quic/core/tls_chlo_extractor_test.cc
@@ -31,7 +31,7 @@
QuicSocketAddress(TestPeerIPAddress(), kTestPort), *packet);
std::string detailed_error;
bool retry_token_present;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
*packet, /*expected_destination_connection_id_length=*/0,
&packet_info.form, &packet_info.long_packet_type,
@@ -128,7 +128,7 @@
QuicSocketAddress(TestPeerIPAddress(), kTestPort), *packets_[0]);
std::string detailed_error;
bool retry_token_present;
- quiche::QuicheStringPiece retry_token;
+ absl::string_view retry_token;
const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
*packets_[0], /*expected_destination_connection_id_length=*/0,
&packet_info.form, &packet_info.long_packet_type,
diff --git a/quic/core/tls_client_handshaker.cc b/quic/core/tls_client_handshaker.cc
index ba3f9d4..c6e601e 100644
--- a/quic/core/tls_client_handshaker.cc
+++ b/quic/core/tls_client_handshaker.cc
@@ -7,6 +7,7 @@
#include <cstring>
#include <string>
+#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_client_config.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
@@ -15,7 +16,6 @@
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
@@ -189,7 +189,7 @@
success && (SSL_set_alpn_protos(ssl(), alpn, alpn_writer.length()) == 0);
if (!success) {
QUIC_BUG << "Failed to set ALPN: "
- << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
+ << quiche::QuicheTextUtils::HexDump(absl::string_view(
alpn_writer.data(), alpn_writer.length()));
return false;
}
@@ -616,7 +616,7 @@
}
void TlsClientHandshaker::WriteMessage(EncryptionLevel level,
- quiche::QuicheStringPiece data) {
+ absl::string_view data) {
if (level == ENCRYPTION_HANDSHAKE &&
state_ < STATE_ENCRYPTION_HANDSHAKE_DATA_SENT) {
state_ = STATE_ENCRYPTION_HANDSHAKE_DATA_SENT;
diff --git a/quic/core/tls_client_handshaker.h b/quic/core/tls_client_handshaker.h
index 2a09fb8..89388cc 100644
--- a/quic/core/tls_client_handshaker.h
+++ b/quic/core/tls_client_handshaker.h
@@ -9,6 +9,7 @@
#include <memory>
#include <string>
+#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "net/third_party/quiche/src/quic/core/crypto/proof_verifier.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_client_config.h"
@@ -18,7 +19,6 @@
#include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
#include "net/third_party/quiche/src/quic/core/tls_handshaker.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -69,8 +69,7 @@
const std::vector<uint8_t>& write_secret) override;
// Override to drop initial keys if trying to write ENCRYPTION_HANDSHAKE data.
- void WriteMessage(EncryptionLevel level,
- quiche::QuicheStringPiece data) override;
+ void WriteMessage(EncryptionLevel level, absl::string_view data) override;
void SetServerApplicationStateForResumption(
std::unique_ptr<ApplicationState> application_state) override;
diff --git a/quic/core/tls_client_handshaker_test.cc b/quic/core/tls_client_handshaker_test.cc
index bfd937f..6a05159 100644
--- a/quic/core/tls_client_handshaker_test.cc
+++ b/quic/core/tls_client_handshaker_test.cc
@@ -52,7 +52,7 @@
const uint16_t port,
const std::string& server_config,
QuicTransportVersion quic_version,
- quiche::QuicheStringPiece chlo_hash,
+ absl::string_view chlo_hash,
const std::vector<std::string>& certs,
const std::string& cert_sct,
const std::string& signature,
@@ -233,10 +233,9 @@
server_session_.reset(server_session);
std::string alpn = AlpnForVersion(connection_->version());
EXPECT_CALL(*server_session_, SelectAlpn(_))
- .WillRepeatedly(
- [alpn](const std::vector<quiche::QuicheStringPiece>& alpns) {
- return std::find(alpns.cbegin(), alpns.cend(), alpn);
- });
+ .WillRepeatedly([alpn](const std::vector<absl::string_view>& alpns) {
+ return std::find(alpns.cbegin(), alpns.cend(), alpn);
+ });
}
MockQuicConnectionHelper server_helper_;
@@ -286,8 +285,8 @@
0, 0, 0, // uint24 length
};
stream()->crypto_message_parser()->ProcessInput(
- quiche::QuicheStringPiece(bogus_handshake_message,
- QUICHE_ARRAYSIZE(bogus_handshake_message)),
+ absl::string_view(bogus_handshake_message,
+ QUICHE_ARRAYSIZE(bogus_handshake_message)),
ENCRYPTION_INITIAL);
EXPECT_FALSE(stream()->one_rtt_keys_available());
@@ -556,10 +555,9 @@
InitializeFakeServer();
const std::string kTestAlpn = "An ALPN That Client Did Not Offer";
EXPECT_CALL(*server_session_, SelectAlpn(_))
- .WillOnce(
- [kTestAlpn](const std::vector<quiche::QuicheStringPiece>& alpns) {
- return std::find(alpns.cbegin(), alpns.cend(), kTestAlpn);
- });
+ .WillOnce([kTestAlpn](const std::vector<absl::string_view>& alpns) {
+ return std::find(alpns.cbegin(), alpns.cend(), kTestAlpn);
+ });
EXPECT_CALL(*server_connection_,
CloseConnection(QUIC_HANDSHAKE_FAILED,
"TLS handshake failure (ENCRYPTION_INITIAL) 120: "
diff --git a/quic/core/tls_handshaker.cc b/quic/core/tls_handshaker.cc
index 04fab15..7e66302 100644
--- a/quic/core/tls_handshaker.cc
+++ b/quic/core/tls_handshaker.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/tls_handshaker.h"
+#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/crypto.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
@@ -11,7 +12,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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 {
@@ -20,7 +20,7 @@
TlsHandshaker::~TlsHandshaker() {}
-bool TlsHandshaker::ProcessInput(quiche::QuicheStringPiece input,
+bool TlsHandshaker::ProcessInput(absl::string_view input,
EncryptionLevel level) {
if (parser_error_ != QUIC_NO_ERROR) {
return false;
@@ -88,7 +88,7 @@
}
void TlsHandshaker::WriteMessage(EncryptionLevel level,
- quiche::QuicheStringPiece data) {
+ absl::string_view data) {
stream_->WriteCryptoData(level, data);
}
diff --git a/quic/core/tls_handshaker.h b/quic/core/tls_handshaker.h
index 2b3c9fc..ef3ade1 100644
--- a/quic/core/tls_handshaker.h
+++ b/quic/core/tls_handshaker.h
@@ -5,6 +5,7 @@
#ifndef QUICHE_QUIC_CORE_TLS_HANDSHAKER_H_
#define QUICHE_QUIC_CORE_TLS_HANDSHAKER_H_
+#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/base.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
@@ -14,7 +15,6 @@
#include "net/third_party/quiche/src/quic/core/crypto/tls_connection.h"
#include "net/third_party/quiche/src/quic/core/quic_session.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -36,8 +36,7 @@
~TlsHandshaker() override;
// From CryptoMessageParser
- bool ProcessInput(quiche::QuicheStringPiece input,
- EncryptionLevel level) override;
+ bool ProcessInput(absl::string_view input, EncryptionLevel level) override;
size_t InputBytesRemaining() const override { return 0; }
QuicErrorCode error() const override { return parser_error_; }
const std::string& error_detail() const override {
@@ -88,8 +87,7 @@
// WriteMessage is called when there is |data| from the TLS stack ready for
// the QUIC stack to write in a crypto frame. The data must be transmitted at
// encryption level |level|.
- void WriteMessage(EncryptionLevel level,
- quiche::QuicheStringPiece data) override;
+ void WriteMessage(EncryptionLevel level, absl::string_view data) override;
// FlushFlight is called to signal that the current flight of
// messages have all been written (via calls to WriteMessage) and can be
diff --git a/quic/core/tls_server_handshaker.cc b/quic/core/tls_server_handshaker.cc
index a8f926e..f108a32 100644
--- a/quic/core/tls_server_handshaker.cc
+++ b/quic/core/tls_server_handshaker.cc
@@ -7,6 +7,7 @@
#include <memory>
#include <string>
+#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/pool.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_server_config.h"
@@ -14,7 +15,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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 {
@@ -423,7 +423,7 @@
size_t* out_len,
size_t max_out,
uint16_t sig_alg,
- quiche::QuicheStringPiece in) {
+ absl::string_view in) {
signature_callback_ = new SignatureCallback(this);
proof_source_->ComputeTlsSignature(
session()->connection()->self_address(),
@@ -461,7 +461,7 @@
int TlsServerHandshaker::SessionTicketSeal(uint8_t* out,
size_t* out_len,
size_t max_out_len,
- quiche::QuicheStringPiece in) {
+ absl::string_view in) {
DCHECK(proof_source_->GetTicketCrypter());
std::vector<uint8_t> ticket = proof_source_->GetTicketCrypter()->Encrypt(in);
if (max_out_len < ticket.size()) {
@@ -480,7 +480,7 @@
uint8_t* out,
size_t* out_len,
size_t max_out_len,
- quiche::QuicheStringPiece in) {
+ absl::string_view in) {
DCHECK(proof_source_->GetTicketCrypter());
if (!ticket_decryption_callback_) {
@@ -586,7 +586,7 @@
CBS all_alpns;
CBS_init(&all_alpns, in, in_len);
- std::vector<quiche::QuicheStringPiece> alpns;
+ std::vector<absl::string_view> alpns;
while (CBS_len(&all_alpns) > 0) {
CBS alpn;
if (!CBS_get_u8_length_prefixed(&all_alpns, &alpn)) {
diff --git a/quic/core/tls_server_handshaker.h b/quic/core/tls_server_handshaker.h
index 063e5ca..79d19cb 100644
--- a/quic/core/tls_server_handshaker.h
+++ b/quic/core/tls_server_handshaker.h
@@ -7,6 +7,7 @@
#include <string>
+#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/pool.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_server_config.h"
@@ -16,7 +17,6 @@
#include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
#include "net/third_party/quiche/src/quic/core/tls_handshaker.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
@@ -94,12 +94,11 @@
uint8_t* out_len,
const uint8_t* in,
unsigned in_len) override;
- ssl_private_key_result_t PrivateKeySign(
- uint8_t* out,
- size_t* out_len,
- size_t max_out,
- uint16_t sig_alg,
- quiche::QuicheStringPiece in) override;
+ ssl_private_key_result_t PrivateKeySign(uint8_t* out,
+ size_t* out_len,
+ size_t max_out,
+ uint16_t sig_alg,
+ absl::string_view in) override;
ssl_private_key_result_t PrivateKeyComplete(uint8_t* out,
size_t* out_len,
size_t max_out) override;
@@ -107,12 +106,11 @@
int SessionTicketSeal(uint8_t* out,
size_t* out_len,
size_t max_out_len,
- quiche::QuicheStringPiece in) override;
- ssl_ticket_aead_result_t SessionTicketOpen(
- uint8_t* out,
- size_t* out_len,
- size_t max_out_len,
- quiche::QuicheStringPiece in) override;
+ absl::string_view in) override;
+ ssl_ticket_aead_result_t SessionTicketOpen(uint8_t* out,
+ size_t* out_len,
+ size_t max_out_len,
+ absl::string_view in) override;
TlsConnection::Delegate* ConnectionDelegate() override { return this; }
private:
diff --git a/quic/core/tls_server_handshaker_test.cc b/quic/core/tls_server_handshaker_test.cc
index 295af9d..b95b281 100644
--- a/quic/core/tls_server_handshaker_test.cc
+++ b/quic/core/tls_server_handshaker_test.cc
@@ -6,6 +6,7 @@
#include <utility>
#include <vector>
+#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/proof_source.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
#include "net/third_party/quiche/src/quic/core/quic_crypto_client_stream.h"
@@ -23,7 +24,6 @@
#include "net/third_party/quiche/src/quic/test_tools/simple_session_cache.h"
#include "net/third_party/quiche/src/quic/test_tools/test_ticket_crypter.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
namespace quic {
class QuicConnection;
@@ -101,7 +101,7 @@
.Times(testing::AnyNumber());
EXPECT_CALL(*server_session_, SelectAlpn(_))
.WillRepeatedly(
- [this](const std::vector<quiche::QuicheStringPiece>& alpns) {
+ [this](const std::vector<absl::string_view>& alpns) {
return std::find(
alpns.cbegin(), alpns.cend(),
AlpnForVersion(server_session_->connection()->version()));
@@ -295,8 +295,8 @@
0, 0, 0, // uint24 length
};
server_stream()->crypto_message_parser()->ProcessInput(
- quiche::QuicheStringPiece(bogus_handshake_message,
- QUICHE_ARRAYSIZE(bogus_handshake_message)),
+ absl::string_view(bogus_handshake_message,
+ QUICHE_ARRAYSIZE(bogus_handshake_message)),
ENCRYPTION_INITIAL);
EXPECT_FALSE(server_stream()->one_rtt_keys_available());
@@ -330,15 +330,13 @@
EXPECT_CALL(*client_session_, GetAlpnsToOffer())
.WillRepeatedly(Return(kTestAlpns));
EXPECT_CALL(*server_session_, SelectAlpn(_))
- .WillOnce([kTestAlpn, kTestAlpns](
- const std::vector<quiche::QuicheStringPiece>& alpns) {
- EXPECT_THAT(alpns, testing::ElementsAreArray(kTestAlpns));
- return std::find(alpns.cbegin(), alpns.cend(), kTestAlpn);
- });
- EXPECT_CALL(*client_session_,
- OnAlpnSelected(quiche::QuicheStringPiece(kTestAlpn)));
- EXPECT_CALL(*server_session_,
- OnAlpnSelected(quiche::QuicheStringPiece(kTestAlpn)));
+ .WillOnce(
+ [kTestAlpn, kTestAlpns](const std::vector<absl::string_view>& alpns) {
+ EXPECT_THAT(alpns, testing::ElementsAreArray(kTestAlpns));
+ return std::find(alpns.cbegin(), alpns.cend(), kTestAlpn);
+ });
+ EXPECT_CALL(*client_session_, OnAlpnSelected(absl::string_view(kTestAlpn)));
+ EXPECT_CALL(*server_session_, OnAlpnSelected(absl::string_view(kTestAlpn)));
CompleteCryptoHandshake();
ExpectHandshakeSuccessful();
