Add QuicStringPiece which is actually StringPiece.

net/quic/chromium/quic_test_packet_maker.cc

 // Copyright 2013 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/chromium/quic_test_packet_maker.h"
 
 #include <list>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 253 matching lines @@
   return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
 }
 
 // Returns a newly created packet to send kData on stream 1.
 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeDataPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     QuicStreamOffset offset,
-    base::StringPiece data) {
+    QuicStringPiece data) {
   InitializeHeader(packet_number, should_include_version);
   QuicStreamFrame frame(stream_id, fin, offset, data);
   DVLOG(1) << "Adding frame: " << frame;
   return MakePacket(header_, QuicFrame(&frame));
 }
 
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeMultipleDataFramesPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     QuicStreamOffset offset,
     const std::vector<std::string>& data_writes) {
   InitializeHeader(packet_number, should_include_version);
   QuicFrames data_frames;
   // QuicFrame takes a raw pointer. Use a std::vector here so we keep
   // StreamFrames alive until MakeMultipleFramesPacket is done.
   std::vector<std::unique_ptr<QuicStreamFrame>> stream_frames;
   for (size_t i = 0; i < data_writes.size(); ++i) {
     bool is_fin = fin && (i == data_writes.size() - 1);
     stream_frames.push_back(base::MakeUnique<QuicStreamFrame>(
-        stream_id, is_fin, offset, base::StringPiece(data_writes[i])));
+        stream_id, is_fin, offset, QuicStringPiece(data_writes[i])));
     offset += data_writes[i].length();
   }
   for (const auto& stream_frame : stream_frames) {
     QuicFrame quic_frame(stream_frame.get());
     DVLOG(1) << "Adding frame: " << quic_frame;
     data_frames.push_back(quic_frame);
   }
   return MakeMultipleFramesPacket(header_, data_frames);
 }
 
 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckAndDataPacket(
     QuicPacketNumber packet_number,
     bool include_version,
     QuicStreamId stream_id,
     QuicPacketNumber largest_received,
     QuicPacketNumber least_unacked,
     bool fin,
     QuicStreamOffset offset,
-    base::StringPiece data) {
+    QuicStringPiece data) {
   InitializeHeader(packet_number, include_version);
 
   QuicAckFrame ack(MakeAckFrame(largest_received));
   ack.ack_delay_time = QuicTime::Delta::Zero();
   for (QuicPacketNumber i = least_unacked; i <= largest_received; ++i) {
     ack.received_packet_times.push_back(std::make_pair(i, clock_->Now()));
   }
   if (largest_received > 0) {
     ack.packets.Add(1, largest_received + 1);
   }
@@ skipping 28 matching lines @@
   headers_frame.set_weight(Spdy3PriorityToHttp2Weight(priority));
   headers_frame.set_has_priority(true);
   spdy_frame = spdy_request_framer_.SerializeFrame(headers_frame);
 
   if (spdy_headers_frame_length) {
     *spdy_headers_frame_length = spdy_frame.size();
   }
   QuicFrames frames;
   QuicStreamOffset header_offset =
       header_stream_offset == nullptr ? 0 : *header_stream_offset;
-  QuicStreamFrame frame(
-      kHeadersStreamId, false, header_offset,
-      base::StringPiece(spdy_frame.data(), spdy_frame.size()));
+  QuicStreamFrame frame(kHeadersStreamId, false, header_offset,
+                        QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
   frames.push_back(QuicFrame(&frame));
   if (header_stream_offset != nullptr) {
     *header_stream_offset += spdy_frame.size();
   }
 
   QuicStreamOffset offset = 0;
   // QuicFrame takes a raw pointer. Use a std::vector here so we keep
   // StreamFrames alive until MakeMultipleFramesPacket is done.
   std::vector<std::unique_ptr<QuicStreamFrame>> stream_frames;
   for (size_t i = 0; i < data_writes.size(); ++i) {
     bool is_fin = fin && (i == data_writes.size() - 1);
     stream_frames.push_back(base::MakeUnique<QuicStreamFrame>(
-        stream_id, is_fin, offset, base::StringPiece(data_writes[i])));
+        stream_id, is_fin, offset, QuicStringPiece(data_writes[i])));
     offset += data_writes[i].length();
   }
   for (const auto& stream_frame : stream_frames) {
     QuicFrame quic_frame(stream_frame.get());
     DVLOG(1) << "Adding frame: " << quic_frame;
     frames.push_back(quic_frame);
   }
   return MakeMultipleFramesPacket(header_, frames);
 }
 
@@ skipping 29 matching lines @@
   headers_frame.set_weight(Spdy3PriorityToHttp2Weight(priority));
   headers_frame.set_has_priority(true);
   spdy_frame = spdy_request_framer_.SerializeFrame(headers_frame);
 
   if (spdy_headers_frame_length) {
     *spdy_headers_frame_length = spdy_frame.size();
   }
   if (offset != nullptr) {
     QuicStreamFrame frame(
         kHeadersStreamId, false, *offset,
-        base::StringPiece(spdy_frame.data(), spdy_frame.size()));
+        QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     *offset += spdy_frame.size();
     return MakePacket(header_, QuicFrame(&frame));
   } else {
     QuicStreamFrame frame(
         kHeadersStreamId, false, 0,
-        base::StringPiece(spdy_frame.data(), spdy_frame.size()));
+        QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
 
     return MakePacket(header_, QuicFrame(&frame));
   }
 }
 
 // Convenience method for calling MakeRequestHeadersPacket with nullptr for
 // |spdy_headers_frame_length|.
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeRequestHeadersPacketWithOffsetTracking(
     QuicPacketNumber packet_number,
@@ skipping 24 matching lines @@
   SpdyPushPromiseIR promise_frame(stream_id, promised_stream_id,
                                   std::move(headers));
   promise_frame.set_fin(fin);
   spdy_frame = spdy_request_framer_.SerializeFrame(promise_frame);
   if (spdy_headers_frame_length) {
     *spdy_headers_frame_length = spdy_frame.size();
   }
   if (offset != nullptr) {
     QuicStreamFrame frame(
         kHeadersStreamId, false, *offset,
-        base::StringPiece(spdy_frame.data(), spdy_frame.size()));
+        QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     *offset += spdy_frame.size();
     return MakePacket(header_, QuicFrame(&frame));
   } else {
     QuicStreamFrame frame(
         kHeadersStreamId, false, 0,
-        base::StringPiece(spdy_frame.data(), spdy_frame.size()));
+        QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     return MakePacket(header_, QuicFrame(&frame));
   }
 }
 
 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeForceHolDataPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     QuicStreamOffset* offset,
-    base::StringPiece data) {
+    QuicStringPiece data) {
   SpdyDataIR spdy_data(stream_id, data);
   spdy_data.set_fin(fin);
   SpdySerializedFrame spdy_frame(
       spdy_request_framer_.SerializeFrame(spdy_data));
   InitializeHeader(packet_number, should_include_version);
-  QuicStreamFrame quic_frame(kHeadersStreamId, false, *offset,
-                             StringPiece(spdy_frame.data(), spdy_frame.size()));
+  QuicStreamFrame quic_frame(
+      kHeadersStreamId, false, *offset,
+      QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
   *offset += spdy_frame.size();
   return MakePacket(header_, QuicFrame(&quic_frame));
 }
 
 // If |offset| is provided, will use the value when creating the packet.
 // Will also update the value after packet creation.
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeResponseHeadersPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     SpdyHeaderBlock headers,
     size_t* spdy_headers_frame_length,
     QuicStreamOffset* offset) {
   InitializeHeader(packet_number, should_include_version);
   SpdySerializedFrame spdy_frame;
   SpdyHeadersIR headers_frame(stream_id, std::move(headers));
   headers_frame.set_fin(fin);
   spdy_frame = spdy_response_framer_.SerializeFrame(headers_frame);
 
   if (spdy_headers_frame_length) {
     *spdy_headers_frame_length = spdy_frame.size();
   }
   if (offset != nullptr) {
     QuicStreamFrame frame(
         kHeadersStreamId, false, *offset,
-        base::StringPiece(spdy_frame.data(), spdy_frame.size()));
+        QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     *offset += spdy_frame.size();
     return MakePacket(header_, QuicFrame(&frame));
   } else {
     QuicStreamFrame frame(
         kHeadersStreamId, false, 0,
-        base::StringPiece(spdy_frame.data(), spdy_frame.size()));
+        QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     return MakePacket(header_, QuicFrame(&frame));
   }
 }
 
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeResponseHeadersPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
@@ skipping 87 matching lines @@
     bool should_include_version,
     QuicStreamOffset* offset) {
   SpdySettingsIR settings_frame;
   settings_frame.AddSetting(id, value);
   SpdySerializedFrame spdy_frame(
       spdy_request_framer_.SerializeFrame(settings_frame));
   InitializeHeader(packet_number, should_include_version);
   if (offset != nullptr) {
     QuicStreamFrame quic_frame(
         kHeadersStreamId, false, *offset,
-        StringPiece(spdy_frame.data(), spdy_frame.size()));
+        QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     *offset += spdy_frame.size();
     return MakePacket(header_, QuicFrame(&quic_frame));
   }
-  QuicStreamFrame quic_frame(kHeadersStreamId, false, 0,
-                             StringPiece(spdy_frame.data(), spdy_frame.size()));
+  QuicStreamFrame quic_frame(
+      kHeadersStreamId, false, 0,
+      QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
   return MakePacket(header_, QuicFrame(&quic_frame));
 }
 
 }  // namespace test
 }  // namespace net