Add QuicStringPiece which is actually StringPiece.

net/quic/core/quic_stream_sequencer_buffer.h

 // Copyright (c) 2015 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.
 
 #ifndef NET_QUIC_CORE_QUIC_STREAM_SEQUENCER_BUFFER_H_
 #define NET_QUIC_CORE_QUIC_STREAM_SEQUENCER_BUFFER_H_
 
 // QuicStreamSequencerBuffer is a circular stream buffer with random write and
 // in-sequence read. It consists of a vector of pointers pointing
 // to memory blocks created as needed and a list of Gaps to indicate
@@ skipping 10 matching lines @@
 //
 // QuicStreamSequencerBuffer maintains a concept of the readable region, which
 // contains all written data that has not been read.
 // It promises stability of the underlying memory addresses in the readable
 // region, so pointers into it can be maintained, and the offset of a pointer
 // from the start of the read region can be calculated.
 //
 // Expected Use:
 //  QuicStreamSequencerBuffer buffer(2.5 * 8 * 1024);
 //  std::string source(1024, 'a');
-//  base::StringPiece std::string_piece(source.data(), source.size());
+//  QuicStringPiece std::string_piece(source.data(), source.size());
 //  size_t written = 0;
 //  buffer.OnStreamData(800, std::string_piece, GetEpollClockNow(), &written);
 //  source = std::string{800, 'b'};
-//  base::StringPiece std::string_piece1(source.data(), 800);
+//  QuicStringPiece std::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, std::string_piece1, &written));
 //  // write to [0, 800), res should be QUIC_NO_ERROR
 //  auto res = buffer.OnStreamData(0, std::string_piece1, GetEpollClockNow(),
 //                                  &written);
 //
 //  // Read into a iovec array with total capacity of 120 bytes.
 //  char dest[120];
 //  iovec iovecs[3]{iovec{dest, 40}, iovec{dest + 40, 40},
@@ skipping 14 matching lines @@
 //  buffer.MarkConsumed(consumed);
 
 #include <cstddef>
 #include <functional>
 #include <list>
 #include <memory>
 
 #include "base/macros.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/platform/api/quic_export.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 
 namespace net {
 
 namespace test {
 class QuicStreamSequencerBufferPeer;
 }  // namespace test
 
 class QUIC_EXPORT_PRIVATE QuicStreamSequencerBuffer {
  public:
   // A Gap indicates a missing chunk of bytes between
@@ skipping 30 matching lines @@
   void Clear();
 
   // Returns true if there is nothing to read in this buffer.
   bool Empty() const;
 
   // Called to buffer new data received for this stream.  If the data was
   // successfully buffered, returns QUIC_NO_ERROR and stores the number of
   // bytes buffered in |bytes_buffered|. Returns an error otherwise.
   // |timestamp| is the time the data arrived.
   QuicErrorCode OnStreamData(QuicStreamOffset offset,
-                             base::StringPiece data,
+                             QuicStringPiece data,
                              QuicTime timestamp,
                              size_t* bytes_buffered,
                              std::string* error_details);
 
   // Reads from this buffer into given iovec array, up to number of iov_len
   // iovec objects and returns the number of bytes read.
   QuicErrorCode Readv(const struct iovec* dest_iov,
                       size_t dest_count,
                       size_t* bytes_read,
                       std::string* error_details);
@@ skipping 116 matching lines @@
   // For debugging use after free, assigned to 123456 in constructor and 654321
   // in destructor. As long as it's not 123456, this means either use after free
   // or memory corruption.
   int32_t destruction_indicator_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamSequencerBuffer);
 };
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_STREAM_SEQUENCER_BUFFER_H_