Add SpdyString alias for std::string in net/spdy.

net/spdy/platform/api/spdy_string_utils_test.cc

 // Copyright 2017 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/spdy/platform/api/spdy_string_utils.h"
 
 #include <cstdint>
 
 #include "net/spdy/platform/api/spdy_string_piece.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 namespace {
 
 TEST(SpdyStringUtilsTest, SpdyStrCat) {
   // No arguments.
   EXPECT_EQ("", SpdyStrCat());
 
   // Single string-like argument.
   const char kFoo[] = "foo";
-  const std::string string_foo(kFoo);
+  const SpdyString string_foo(kFoo);
   const SpdyStringPiece stringpiece_foo(string_foo);
   EXPECT_EQ("foo", SpdyStrCat(kFoo));
   EXPECT_EQ("foo", SpdyStrCat(string_foo));
   EXPECT_EQ("foo", SpdyStrCat(stringpiece_foo));
 
   // Two string-like arguments.
   const char kBar[] = "bar";
   const SpdyStringPiece stringpiece_bar(kBar);
-  const std::string string_bar(kBar);
+  const SpdyString string_bar(kBar);
   EXPECT_EQ("foobar", SpdyStrCat(kFoo, kBar));
   EXPECT_EQ("foobar", SpdyStrCat(kFoo, string_bar));
   EXPECT_EQ("foobar", SpdyStrCat(kFoo, stringpiece_bar));
   EXPECT_EQ("foobar", SpdyStrCat(string_foo, kBar));
   EXPECT_EQ("foobar", SpdyStrCat(string_foo, string_bar));
   EXPECT_EQ("foobar", SpdyStrCat(string_foo, stringpiece_bar));
   EXPECT_EQ("foobar", SpdyStrCat(stringpiece_foo, kBar));
   EXPECT_EQ("foobar", SpdyStrCat(stringpiece_foo, string_bar));
   EXPECT_EQ("foobar", SpdyStrCat(stringpiece_foo, stringpiece_bar));
 
@@ skipping 23 matching lines @@
 
   // Mixed string-like, numerical, and Boolean arguments.
   EXPECT_EQ("foo1foo081bar3.14151",
             SpdyStrCat(kFoo, i, string_foo, f, u, t, stringpiece_bar, d, t));
   EXPECT_EQ("3.141511bar18bar13.14150",
             SpdyStrCat(d, t, t, string_bar, i, u, kBar, t, d, f));
 }
 
 TEST(SpdyStringUtilsTest, SpdyStrAppend) {
   // No arguments on empty string.
-  std::string output;
+  SpdyString output;
   SpdyStrAppend(&output);
   EXPECT_TRUE(output.empty());
 
   // Single string-like argument.
   const char kFoo[] = "foo";
-  const std::string string_foo(kFoo);
+  const SpdyString string_foo(kFoo);
   const SpdyStringPiece stringpiece_foo(string_foo);
   SpdyStrAppend(&output, kFoo);
   EXPECT_EQ("foo", output);
   SpdyStrAppend(&output, string_foo);
   EXPECT_EQ("foofoo", output);
   SpdyStrAppend(&output, stringpiece_foo);
   EXPECT_EQ("foofoofoo", output);
 
   // No arguments on non-empty string.
   SpdyStrAppend(&output);
   EXPECT_EQ("foofoofoo", output);
 
   output.clear();
 
   // Two string-like arguments.
   const char kBar[] = "bar";
   const SpdyStringPiece stringpiece_bar(kBar);
-  const std::string string_bar(kBar);
+  const SpdyString string_bar(kBar);
   SpdyStrAppend(&output, kFoo, kBar);
   EXPECT_EQ("foobar", output);
   SpdyStrAppend(&output, kFoo, string_bar);
   EXPECT_EQ("foobarfoobar", output);
   SpdyStrAppend(&output, kFoo, stringpiece_bar);
   EXPECT_EQ("foobarfoobarfoobar", output);
   SpdyStrAppend(&output, string_foo, kBar);
   EXPECT_EQ("foobarfoobarfoobarfoobar", output);
 
   output.clear();
@@ skipping 56 matching lines @@
 }
 
 TEST(SpdyStringUtilsTest, SpdyStringPrintf) {
   EXPECT_EQ("", SpdyStringPrintf("%s", ""));
   EXPECT_EQ("foobar", SpdyStringPrintf("%sbar", "foo"));
   EXPECT_EQ("foobar", SpdyStringPrintf("%s%s", "foo", "bar"));
   EXPECT_EQ("foo: 1, bar: 2.0", SpdyStringPrintf("foo: %d, bar: %.1f", 1, 2.0));
 }
 
 TEST(SpdyStringUtilsTest, SpdyStringAppendF) {
-  std::string output;
+  SpdyString output;
 
   SpdyStringAppendF(&output, "%s", "");
   EXPECT_TRUE(output.empty());
 
   SpdyStringAppendF(&output, "%sbar", "foo");
   EXPECT_EQ("foobar", output);
 
   SpdyStringAppendF(&output, "%s%s", "foo", "bar");
   EXPECT_EQ("foobarfoobar", output);
 
@@ skipping 24 matching lines @@
   EXPECT_EQ(11, SpdyHexDigitToInt('B'));
   EXPECT_EQ(12, SpdyHexDigitToInt('C'));
   EXPECT_EQ(13, SpdyHexDigitToInt('D'));
   EXPECT_EQ(14, SpdyHexDigitToInt('E'));
   EXPECT_EQ(15, SpdyHexDigitToInt('F'));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net