Add QuicStringPiece which is actually StringPiece.

net/quic/core/quic_framer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/core/quic_framer.h"
 
 #include <cstdint>
 #include <memory>
 
 #include "base/compiler_specific.h"
 #include "net/quic/core/crypto/crypto_framer.h"
 #include "net/quic/core/crypto/crypto_handshake_message.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/crypto/null_decrypter.h"
 #include "net/quic/core/crypto/null_encrypter.h"
 #include "net/quic/core/crypto/quic_decrypter.h"
 #include "net/quic/core/crypto/quic_encrypter.h"
 #include "net/quic/core/quic_data_reader.h"
 #include "net/quic/core/quic_data_writer.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_socket_address_coder.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_aligned.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_map_util.h"
 #include "net/quic/platform/api/quic_ptr_util.h"
 
-using base::StringPiece;
 using std::string;
 
 namespace net {
 
 namespace {
 
 #define ENDPOINT \
   (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
 // Mask to select the lowest 48 bits of a packet number.
@@ skipping 589 matching lines @@
     set_detailed_error("Incorrect message tag.");
     return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
   }
 
   if (reset->GetUint64(kRNON, &packet.nonce_proof) != QUIC_NO_ERROR) {
     set_detailed_error("Unable to read nonce proof.");
     return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
   }
   // TODO(satyamshekhar): validate nonce to protect against DoS.
 
-  StringPiece address;
+  QuicStringPiece address;
   if (reset->GetStringPiece(kCADR, &address)) {
     QuicSocketAddressCoder address_coder;
     if (address_coder.Decode(address.data(), address.length())) {
       packet.client_address =
           QuicSocketAddress(address_coder.ip(), address_coder.port());
     }
   }
 
   visitor_->OnPublicResetPacket(packet);
   return true;
@@ skipping 518 matching lines @@
     set_detailed_error("Unable to read stream_id.");
     return false;
   }
 
   frame->offset = 0;
   if (!reader->ReadBytes(&frame->offset, offset_length)) {
     set_detailed_error("Unable to read offset.");
     return false;
   }
 
-  // TODO(ianswett): Don't use StringPiece as an intermediary.
-  StringPiece data;
+  // TODO(ianswett): Don't use QuicStringPiece as an intermediary.
+  QuicStringPiece data;
   if (has_data_length) {
     if (!reader->ReadStringPiece16(&data)) {
       set_detailed_error("Unable to read frame data.");
       return false;
     }
   } else {
     if (!reader->ReadStringPiece(&data, reader->BytesRemaining())) {
       set_detailed_error("Unable to read frame data.");
       return false;
     }
@@ skipping 187 matching lines @@
     return false;
   }
 
   if (error_code >= QUIC_LAST_ERROR) {
     // Ignore invalid QUIC error code if any.
     error_code = QUIC_LAST_ERROR;
   }
 
   frame->error_code = static_cast<QuicErrorCode>(error_code);
 
-  StringPiece error_details;
+  QuicStringPiece error_details;
   if (!reader->ReadStringPiece16(&error_details)) {
     set_detailed_error("Unable to read connection close error details.");
     return false;
   }
   frame->error_details = error_details.as_string();
 
   return true;
 }
 
 bool QuicFramer::ProcessGoAwayFrame(QuicDataReader* reader,
@@ skipping 10 matching lines @@
   }
   frame->error_code = static_cast<QuicErrorCode>(error_code);
 
   uint32_t stream_id;
   if (!reader->ReadUInt32(&stream_id)) {
     set_detailed_error("Unable to read last good stream id.");
     return false;
   }
   frame->last_good_stream_id = static_cast<QuicStreamId>(stream_id);
 
-  StringPiece reason_phrase;
+  QuicStringPiece reason_phrase;
   if (!reader->ReadStringPiece16(&reason_phrase)) {
     set_detailed_error("Unable to read goaway reason.");
     return false;
   }
   frame->reason_phrase = reason_phrase.as_string();
 
   return true;
 }
 
 bool QuicFramer::ProcessWindowUpdateFrame(QuicDataReader* reader,
@@ skipping 25 matching lines @@
                                        QuicPathCloseFrame* frame) {
   if (!reader->ReadBytes(&frame->path_id, 1)) {
     set_detailed_error("Unable to read path_id.");
     return false;
   }
 
   return true;
 }
 
 // static
-StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
+QuicStringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
     QuicVersion version,
     const QuicEncryptedPacket& encrypted,
     QuicConnectionIdLength connection_id_length,
     bool includes_version,
     bool includes_diversification_nonce,
     QuicPacketNumberLength packet_number_length) {
   // TODO(ianswett): This is identical to QuicData::AssociatedData.
-  return StringPiece(encrypted.data(),
-                     GetStartOfEncryptedData(
-                         version, connection_id_length, includes_version,
-                         includes_diversification_nonce, packet_number_length));
+  return QuicStringPiece(
+      encrypted.data(),
+      GetStartOfEncryptedData(version, connection_id_length, includes_version,
+                              includes_diversification_nonce,
+                              packet_number_length));
 }
 
 void QuicFramer::SetDecrypter(EncryptionLevel level, QuicDecrypter* decrypter) {
   DCHECK(alternative_decrypter_.get() == nullptr);
   DCHECK_GE(level, decrypter_level_);
   decrypter_.reset(decrypter);
   decrypter_level_ = level;
 }
 
 void QuicFramer::SetAlternativeDecrypter(EncryptionLevel level,
@@ skipping 20 matching lines @@
 
 size_t QuicFramer::EncryptInPlace(EncryptionLevel level,
                                   QuicPacketNumber packet_number,
                                   size_t ad_len,
                                   size_t total_len,
                                   size_t buffer_len,
                                   char* buffer) {
   size_t output_length = 0;
   if (!encrypter_[level]->EncryptPacket(
           quic_version_, packet_number,
-          StringPiece(buffer, ad_len),                       // Associated data
-          StringPiece(buffer + ad_len, total_len - ad_len),  // Plaintext
+          QuicStringPiece(buffer, ad_len),  // Associated data
+          QuicStringPiece(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;
   }
 
   return ad_len + output_length;
 }
 
 size_t QuicFramer::EncryptPayload(EncryptionLevel level,
                                   QuicPacketNumber packet_number,
                                   const QuicPacket& packet,
                                   char* buffer,
                                   size_t buffer_len) {
   DCHECK(encrypter_[level].get() != nullptr);
 
-  StringPiece associated_data = packet.AssociatedData(quic_version_);
+  QuicStringPiece associated_data = packet.AssociatedData(quic_version_);
   // Copy in the header, because the encrypter only populates the encrypted
   // plaintext content.
   const size_t ad_len = associated_data.length();
   memmove(buffer, associated_data.data(), ad_len);
   // Encrypt the plaintext into the buffer.
   size_t output_length = 0;
   if (!encrypter_[level]->EncryptPacket(
           quic_version_, packet_number, associated_data,
           packet.Plaintext(quic_version_), buffer + ad_len, &output_length,
           buffer_len - ad_len)) {
@@ skipping 20 matching lines @@
 
   return min_plaintext_size;
 }
 
 bool QuicFramer::DecryptPayload(QuicDataReader* encrypted_reader,
                                 const QuicPacketHeader& header,
                                 const QuicEncryptedPacket& packet,
                                 char* decrypted_buffer,
                                 size_t buffer_length,
                                 size_t* decrypted_length) {
-  StringPiece encrypted = encrypted_reader->ReadRemainingPayload();
+  QuicStringPiece encrypted = encrypted_reader->ReadRemainingPayload();
   DCHECK(decrypter_.get() != nullptr);
-  StringPiece associated_data = GetAssociatedDataFromEncryptedPacket(
+  QuicStringPiece associated_data = GetAssociatedDataFromEncryptedPacket(
       quic_version_, packet, header.public_header.connection_id_length,
       header.public_header.version_flag, header.public_header.nonce != nullptr,
       header.public_header.packet_number_length);
 
   bool success = decrypter_->DecryptPacket(
       quic_version_, header.packet_number, associated_data, encrypted,
       decrypted_buffer, decrypted_length, buffer_length);
   if (success) {
     visitor_->OnDecryptedPacket(decrypter_level_);
   } else if (alternative_decrypter_.get() != nullptr) {
@@ skipping 557 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   QUIC_DLOG(INFO) << ENDPOINT << "Error: " << QuicErrorCodeToString(error)
                   << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net