Add QuicStringPiece which is actually StringPiece.

net/quic/core/quic_headers_stream_test.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/core/quic_headers_stream.h"
 
 #include <cstdint>
 #include <ostream>
 #include <string>
 #include <tuple>
 #include <utility>
 
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_ptr_util.h"
 #include "net/quic/platform/api/quic_str_cat.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_stream_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_flags.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using base::StringPiece;
 using std::string;
 using testing::_;
 using testing::AtLeast;
 using testing::HasSubstr;
 using testing::InSequence;
 using testing::Invoke;
 using testing::Return;
 using testing::StrictMock;
 using testing::WithArgs;
 
@@ skipping 52 matching lines @@
   MOCK_METHOD2(OnWindowUpdate,
                void(SpdyStreamId stream_id, int delta_window_size));
   MOCK_METHOD1(OnBlocked, void(SpdyStreamId stream_id));
   MOCK_METHOD3(OnPushPromise,
                void(SpdyStreamId stream_id,
                     SpdyStreamId promised_stream_id,
                     bool end));
   MOCK_METHOD2(OnContinuation, void(SpdyStreamId stream_id, bool end));
   MOCK_METHOD3(OnAltSvc,
                void(SpdyStreamId stream_id,
-                    StringPiece origin,
+                    QuicStringPiece origin,
                     const SpdyAltSvcWireFormat::AlternativeServiceVector&
                         altsvc_vector));
   MOCK_METHOD4(OnPriority,
                void(SpdyStreamId stream_id,
                     SpdyStreamId parent_stream_id,
                     int weight,
                     bool exclusive));
   MOCK_METHOD2(OnUnknownFrame,
                bool(SpdyStreamId stream_id, uint8_t frame_type));
 };
@@ skipping 160 matching lines @@
 
   void SavePayload(const char* data, size_t len) {
     saved_payloads_.append(data, len);
   }
 
   bool SaveHeaderData(const char* data, int len) {
     saved_header_data_.append(data, len);
     return true;
   }
 
-  void SaveHeaderDataStringPiece(StringPiece data) {
+  void SaveHeaderDataStringPiece(QuicStringPiece data) {
     saved_header_data_.append(data.data(), data.length());
   }
 
   void SavePromiseHeaderList(QuicStreamId /* stream_id */,
                              QuicStreamId /* promised_stream_id */,
                              size_t size,
                              const QuicHeaderList& header_list) {
     SaveToHandler(size, header_list);
   }
 
@@ skipping 745 matching lines @@
   consumed_data = session_.WritevStreamData(id, MakeIOVector(data, &iov),
                                             offset, fin, nullptr);
 
   EXPECT_EQ(consumed_data.bytes_consumed, 0u);
   EXPECT_EQ(consumed_data.fin_consumed, false);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net