Add QuicStringPiece which is actually StringPiece.

net/quic/core/spdy_utils_test.cc

 // Copyright 2016 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/spdy_utils.h"
 
 #include "base/macros.h"
-#include "base/strings/string_piece.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using base::StringPiece;
 using std::string;
 using testing::UnorderedElementsAre;
 using testing::Pair;
 
 namespace net {
 namespace test {
 
 TEST(SpdyUtilsTest, SerializeAndParseHeaders) {
   // Creates a SpdyHeaderBlock with some key->value pairs, serializes it, then
   // parses the serialized output and verifies that the end result is the same
@@ skipping 155 matching lines @@
                            {"empty-joined", ""},
                            {"empty-joined", ""},
 
                            // Non-continguous cookie crumb.
                            {"cookie", " fin!"}});
 
   int64_t content_length = -1;
   SpdyHeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
-  EXPECT_THAT(block, UnorderedElementsAre(
-                         Pair("cookie", " part 1; part 2 ; part3;  fin!"),
-                         Pair("passed-through", StringPiece("foo\0baz", 7)),
-                         Pair("joined", StringPiece("value 1\0value 2", 15)),
-                         Pair("empty", ""),
-                         Pair("empty-joined", StringPiece("\0foo\0\0", 6))));
+  EXPECT_THAT(block,
+              UnorderedElementsAre(
+                  Pair("cookie", " part 1; part 2 ; part3;  fin!"),
+                  Pair("passed-through", QuicStringPiece("foo\0baz", 7)),
+                  Pair("joined", QuicStringPiece("value 1\0value 2", 15)),
+                  Pair("empty", ""),
+                  Pair("empty-joined", QuicStringPiece("\0foo\0\0", 6))));
   EXPECT_EQ(-1, content_length);
 }
 
 TEST(SpdyUtilsTest, CopyAndValidateHeadersEmptyName) {
   auto headers = FromList({{"foo", "foovalue"}, {"", "barvalue"}, {"baz", ""}});
   int64_t content_length = -1;
   SpdyHeaderBlock block;
   ASSERT_FALSE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
 }
@@ skipping 12 matching lines @@
                            {"foo", "foovalue"},
                            {"content-length", "9"},
                            {"bar", "barvalue"},
                            {"baz", ""}});
   int64_t content_length = -1;
   SpdyHeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
   EXPECT_THAT(block, UnorderedElementsAre(
                          Pair("foo", "foovalue"), Pair("bar", "barvalue"),
-                         Pair("content-length", StringPiece("9"
-                                                            "\0"
-                                                            "9",
-                                                            3)),
+                         Pair("content-length", QuicStringPiece("9"
+                                                                "\0"
+                                                                "9",
+                                                                3)),
                          Pair("baz", "")));
   EXPECT_EQ(9, content_length);
 }
 
 TEST(SpdyUtilsTest, CopyAndValidateHeadersInconsistentContentLengths) {
   auto headers = FromList({{"content-length", "9"},
                            {"foo", "foovalue"},
                            {"content-length", "8"},
                            {"bar", "barvalue"},
                            {"baz", ""}});
   int64_t content_length = -1;
   SpdyHeaderBlock block;
   ASSERT_FALSE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
 }
 
 TEST(SpdyUtilsTest, CopyAndValidateHeadersLargeContentLength) {
   auto headers = FromList({{"content-length", "9000000000"},
                            {"foo", "foovalue"},
                            {"bar", "barvalue"},
                            {"baz", ""}});
   int64_t content_length = -1;
   SpdyHeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
   EXPECT_THAT(block, UnorderedElementsAre(
                          Pair("foo", "foovalue"), Pair("bar", "barvalue"),
-                         Pair("content-length", StringPiece("9000000000")),
+                         Pair("content-length", QuicStringPiece("9000000000")),
                          Pair("baz", "")));
   EXPECT_EQ(9000000000, content_length);
 }
 
 TEST(SpdyUtilsTest, CopyAndValidateHeadersMultipleValues) {
   auto headers = FromList({{"foo", "foovalue"},
                            {"bar", "barvalue"},
                            {"baz", ""},
                            {"foo", "boo"},
                            {"baz", "buzz"}});
   int64_t content_length = -1;
   SpdyHeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
-  EXPECT_THAT(
-      block, UnorderedElementsAre(Pair("foo", StringPiece("foovalue\0boo", 12)),
-                                  Pair("bar", "barvalue"),
-                                  Pair("baz", StringPiece("\0buzz", 5))));
+  EXPECT_THAT(block, UnorderedElementsAre(
+                         Pair("foo", QuicStringPiece("foovalue\0boo", 12)),
+                         Pair("bar", "barvalue"),
+                         Pair("baz", QuicStringPiece("\0buzz", 5))));
   EXPECT_EQ(-1, content_length);
 }
 
 TEST(SpdyUtilsTest, CopyAndValidateHeadersMoreThanTwoValues) {
   auto headers = FromList({{"set-cookie", "value1"},
                            {"set-cookie", "value2"},
                            {"set-cookie", "value3"}});
   int64_t content_length = -1;
   SpdyHeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
-  EXPECT_THAT(block,
-              UnorderedElementsAre(Pair(
-                  "set-cookie", StringPiece("value1\0value2\0value3", 20))));
+  EXPECT_THAT(
+      block, UnorderedElementsAre(Pair(
+                 "set-cookie", QuicStringPiece("value1\0value2\0value3", 20))));
   EXPECT_EQ(-1, content_length);
 }
 
 TEST(SpdyUtilsTest, CopyAndValidateHeadersCookie) {
   auto headers = FromList({{"foo", "foovalue"},
                            {"bar", "barvalue"},
                            {"cookie", "value1"},
                            {"baz", ""}});
   int64_t content_length = -1;
   SpdyHeaderBlock block;
@@ skipping 78 matching lines @@
 TEST(SpdyUtilsTest, PopulateHeaderBlockFromUrlFails) {
   SpdyHeaderBlock headers;
   EXPECT_FALSE(SpdyUtils::PopulateHeaderBlockFromUrl("/", &headers));
   EXPECT_FALSE(SpdyUtils::PopulateHeaderBlockFromUrl("/index.html", &headers));
   EXPECT_FALSE(
       SpdyUtils::PopulateHeaderBlockFromUrl("www.google.com/", &headers));
 }
 
 }  // namespace test
 }  // namespace net