Add QuicStringPiece which is actually StringPiece.

net/quic/core/quic_spdy_session.cc

 // 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.
 
 #include "net/quic/core/quic_spdy_session.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <string>
 #include <utility>
 
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_headers_stream.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_str_cat.h"
 
-using base::StringPiece;
 using std::string;
 
 namespace net {
 
 namespace {
 
 class HeaderTableDebugVisitor
     : public HpackHeaderTable::DebugVisitorInterface {
  public:
   HeaderTableDebugVisitor(const QuicClock* clock,
@@ skipping 374 matching lines @@
     SpdyPriority priority,
     QuicReferenceCountedPointer<QuicAckListenerInterface>
         ack_notifier_delegate) {
   SpdyHeadersIR headers_frame(id, std::move(headers));
   headers_frame.set_fin(fin);
   if (perspective() == Perspective::IS_CLIENT) {
     headers_frame.set_has_priority(true);
     headers_frame.set_weight(Spdy3PriorityToHttp2Weight(priority));
   }
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(headers_frame));
-  headers_stream_->WriteOrBufferData(StringPiece(frame.data(), frame.size()),
-                                     false, std::move(ack_notifier_delegate));
+  headers_stream_->WriteOrBufferData(
+      QuicStringPiece(frame.data(), frame.size()), false,
+      std::move(ack_notifier_delegate));
   return frame.size();
 }
 
 size_t QuicSpdySession::WritePushPromise(QuicStreamId original_stream_id,
                                          QuicStreamId promised_stream_id,
                                          SpdyHeaderBlock headers) {
   if (perspective() == Perspective::IS_CLIENT) {
     QUIC_BUG << "Client shouldn't send PUSH_PROMISE";
     return 0;
   }
 
   SpdyPushPromiseIR push_promise(original_stream_id, promised_stream_id,
                                  std::move(headers));
   // PUSH_PROMISE must not be the last frame sent out, at least followed by
   // response headers.
   push_promise.set_fin(false);
 
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(push_promise));
-  headers_stream_->WriteOrBufferData(StringPiece(frame.data(), frame.size()),
-                                     false, nullptr);
+  headers_stream_->WriteOrBufferData(
+      QuicStringPiece(frame.data(), frame.size()), false, nullptr);
   return frame.size();
 }
 
 void QuicSpdySession::WriteDataFrame(
     QuicStreamId id,
-    StringPiece data,
+    QuicStringPiece data,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   // Note that certain SpdyDataIR constructors perform a deep copy of |data|
   // which should be avoided here.
   SpdyDataIR spdy_data(id);
   spdy_data.SetDataShallow(data);
   spdy_data.set_fin(fin);
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(spdy_data));
   QuicReferenceCountedPointer<ForceHolAckListener> force_hol_ack_listener;
   if (ack_listener != nullptr) {
     force_hol_ack_listener = new ForceHolAckListener(
         std::move(ack_listener), frame.size() - data.length());
   }
   // Use buffered writes so that coherence of framing is preserved
   // between streams.
-  headers_stream_->WriteOrBufferData(StringPiece(frame.data(), frame.size()),
-                                     false, std::move(force_hol_ack_listener));
+  headers_stream_->WriteOrBufferData(
+      QuicStringPiece(frame.data(), frame.size()), false,
+      std::move(force_hol_ack_listener));
 }
 
 QuicConsumedData QuicSpdySession::WritevStreamData(
     QuicStreamId id,
     QuicIOVector iov,
     QuicStreamOffset offset,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   const size_t max_len =
       kSpdyInitialFrameSizeLimit - kDataFrameMinimumSize;
 
   QuicConsumedData result(0, false);
   size_t total_length = iov.total_length;
 
   if (total_length == 0 && fin) {
-    WriteDataFrame(id, StringPiece(), true, std::move(ack_listener));
+    WriteDataFrame(id, QuicStringPiece(), true, std::move(ack_listener));
     result.fin_consumed = true;
     return result;
   }
 
   // Encapsulate the data into HTTP/2 DATA frames.  The outer loop
   // handles each element of the source iov, the inner loop handles
   // the possibility of fragmenting each of those into multiple DATA
   // frames, as the DATA frames have a max size of 16KB.
   for (int i = 0; i < iov.iov_count; i++) {
     size_t src_iov_offset = 0;
     const struct iovec* src_iov = &iov.iov[i];
     do {
       if (headers_stream_->queued_data_bytes() > 0) {
         // Limit the amount of buffering to the minimum needed to
         // preserve framing.
         return result;
       }
       size_t len = std::min(
           std::min(src_iov->iov_len - src_iov_offset, max_len), total_length);
       char* data = static_cast<char*>(src_iov->iov_base) + src_iov_offset;
       src_iov_offset += len;
       offset += len;
       // fin handling, only set it for the final HTTP/2 DATA frame.
       bool last_iov = i == iov.iov_count - 1;
       bool last_fragment_within_iov = src_iov_offset >= src_iov->iov_len;
       bool frame_fin = (last_iov && last_fragment_within_iov) ? fin : false;
-      WriteDataFrame(id, StringPiece(data, len), frame_fin, ack_listener);
+      WriteDataFrame(id, QuicStringPiece(data, len), frame_fin, ack_listener);
       result.bytes_consumed += len;
       if (frame_fin) {
         result.fin_consumed = true;
       }
       DCHECK_GE(total_length, len);
       total_length -= len;
       if (total_length <= 0) {
         return result;
       }
     } while (src_iov_offset < src_iov->iov_len);
   }
 
   return result;
 }
 
 size_t QuicSpdySession::SendMaxHeaderListSize(size_t value) {
   SpdySettingsIR settings_frame;
   settings_frame.AddSetting(SETTINGS_MAX_HEADER_LIST_SIZE, value);
 
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(settings_frame));
-  headers_stream_->WriteOrBufferData(StringPiece(frame.data(), frame.size()),
-                                     false, nullptr);
+  headers_stream_->WriteOrBufferData(
+      QuicStringPiece(frame.data(), frame.size()), false, nullptr);
   return frame.size();
 }
 
 void QuicSpdySession::OnHeadersHeadOfLineBlocking(QuicTime::Delta delta) {
   // Implemented in Chromium for stats tracking.
 }
 
 void QuicSpdySession::RegisterStreamPriority(QuicStreamId id,
                                              SpdyPriority priority) {
   write_blocked_streams()->RegisterStream(id, priority);
@@ skipping 60 matching lines @@
 void QuicSpdySession::OnStreamFrameData(QuicStreamId stream_id,
                                         const char* data,
                                         size_t len,
                                         bool fin) {
   QuicSpdyStream* stream = GetSpdyDataStream(stream_id);
   if (stream == nullptr) {
     return;
   }
   const QuicStreamOffset offset =
       stream->flow_controller()->highest_received_byte_offset();
-  const QuicStreamFrame frame(stream_id, fin, offset, StringPiece(data, len));
+  const QuicStreamFrame frame(stream_id, fin, offset,
+                              QuicStringPiece(data, len));
   QUIC_DVLOG(1) << "De-encapsulating DATA frame for stream " << stream_id
                 << " offset " << offset << " len " << len << " fin " << fin;
   OnStreamFrame(frame);
 }
 
 bool QuicSpdySession::ShouldReleaseHeadersStreamSequencerBuffer() {
   return false;
 }
 
 void QuicSpdySession::OnHeaders(SpdyStreamId stream_id,
@@ skipping 129 matching lines @@
       set_max_uncompressed_header_bytes);
 }
 
 void QuicSpdySession::CloseConnectionWithDetails(QuicErrorCode error,
                                                  const string& details) {
   connection()->CloseConnection(
       error, details, ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
 }
 
 }  // namespace net