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

net/spdy/spdy_alt_svc_wire_format_test.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/spdy/spdy_alt_svc_wire_format.h"
 
 #include "base/logging.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/platform_test.h"
 
 using ::testing::_;
 
 namespace net {
 
 namespace test {
 
 // Expose all private methods of class SpdyAltSvcWireFormat.
 class SpdyAltSvcWireFormatPeer {
  public:
   static void SkipWhiteSpace(SpdyStringPiece::const_iterator* c,
                              SpdyStringPiece::const_iterator end) {
     SpdyAltSvcWireFormat::SkipWhiteSpace(c, end);
   }
   static bool PercentDecode(SpdyStringPiece::const_iterator c,
                             SpdyStringPiece::const_iterator end,
-                            std::string* output) {
+                            SpdyString* output) {
     return SpdyAltSvcWireFormat::PercentDecode(c, end, output);
   }
   static bool ParseAltAuthority(SpdyStringPiece::const_iterator c,
                                 SpdyStringPiece::const_iterator end,
-                                std::string* host,
+                                SpdyString* host,
                                 uint16_t* port) {
     return SpdyAltSvcWireFormat::ParseAltAuthority(c, end, host, port);
   }
   static bool ParsePositiveInteger16(SpdyStringPiece::const_iterator c,
                                      SpdyStringPiece::const_iterator end,
                                      uint16_t* max_age) {
     return SpdyAltSvcWireFormat::ParsePositiveInteger16(c, end, max_age);
   }
   static bool ParsePositiveInteger32(SpdyStringPiece::const_iterator c,
                                      SpdyStringPiece::const_iterator end,
                                      uint32_t* max_age) {
     return SpdyAltSvcWireFormat::ParsePositiveInteger32(c, end, max_age);
   }
 };
 
 }  // namespace test
 
 namespace {
 
 // Generate header field values, possibly with multiply defined parameters and
 // random case, and corresponding AlternativeService entries.
 void FuzzHeaderFieldValue(
     int i,
-    std::string* header_field_value,
+    SpdyString* header_field_value,
     SpdyAltSvcWireFormat::AlternativeService* expected_altsvc) {
   if (!header_field_value->empty()) {
     header_field_value->push_back(',');
   }
   expected_altsvc->protocol_id = "a=b%c";
   header_field_value->append("a%3Db%25c=\"");
   expected_altsvc->host = "";
   if (i & 1 << 0) {
     expected_altsvc->host = "foo\"bar\\baz";
     header_field_value->append("foo\\\"bar\\\\baz");
@@ skipping 36 matching lines @@
   }
   if (i & 1 << 10) {
     header_field_value->append(" ");
   }
 }
 
 // Generate AlternativeService entries and corresponding header field values in
 // canonical form, that is, what SerializeHeaderFieldValue() should output.
 void FuzzAlternativeService(int i,
                             SpdyAltSvcWireFormat::AlternativeService* altsvc,
-                            std::string* expected_header_field_value) {
+                            SpdyString* expected_header_field_value) {
   if (!expected_header_field_value->empty()) {
     expected_header_field_value->push_back(',');
   }
   altsvc->protocol_id = "a=b%c";
   altsvc->port = 42;
   expected_header_field_value->append("a%3Db%25c=\"");
   if (i & 1 << 0) {
     altsvc->host = "foo\"bar\\baz";
     expected_header_field_value->append("foo\\\"bar\\\\baz");
   }
@@ skipping 32 matching lines @@
   ASSERT_TRUE(
       SpdyAltSvcWireFormat::ParseHeaderFieldValue("clear", &altsvc_vector));
   EXPECT_EQ(0u, altsvc_vector.size());
 }
 
 // Fuzz test of ParseHeaderFieldValue() with optional whitespaces, ignored
 // parameters, duplicate parameters, trailing space, trailing alternate service
 // separator, etc.  Single alternative service at a time.
 TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValue) {
   for (int i = 0; i < 1 << 11; ++i) {
-    std::string header_field_value;
+    SpdyString header_field_value;
     SpdyAltSvcWireFormat::AlternativeService expected_altsvc;
     FuzzHeaderFieldValue(i, &header_field_value, &expected_altsvc);
     SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
     ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue(header_field_value,
                                                             &altsvc_vector));
     ASSERT_EQ(1u, altsvc_vector.size());
     EXPECT_EQ(expected_altsvc.protocol_id, altsvc_vector[0].protocol_id);
     EXPECT_EQ(expected_altsvc.host, altsvc_vector[0].host);
     EXPECT_EQ(expected_altsvc.port, altsvc_vector[0].port);
     EXPECT_EQ(expected_altsvc.max_age, altsvc_vector[0].max_age);
     EXPECT_EQ(expected_altsvc.version, altsvc_vector[0].version);
 
     // Roundtrip test starting with |altsvc_vector|.
-    std::string reserialized_header_field_value =
+    SpdyString reserialized_header_field_value =
         SpdyAltSvcWireFormat::SerializeHeaderFieldValue(altsvc_vector);
     SpdyAltSvcWireFormat::AlternativeServiceVector roundtrip_altsvc_vector;
     ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue(
         reserialized_header_field_value, &roundtrip_altsvc_vector));
     ASSERT_EQ(1u, roundtrip_altsvc_vector.size());
     EXPECT_EQ(expected_altsvc.protocol_id,
               roundtrip_altsvc_vector[0].protocol_id);
     EXPECT_EQ(expected_altsvc.host, roundtrip_altsvc_vector[0].host);
     EXPECT_EQ(expected_altsvc.port, roundtrip_altsvc_vector[0].port);
     EXPECT_EQ(expected_altsvc.max_age, roundtrip_altsvc_vector[0].max_age);
     EXPECT_EQ(expected_altsvc.version, roundtrip_altsvc_vector[0].version);
   }
 }
 
 // Fuzz test of ParseHeaderFieldValue() with optional whitespaces, ignored
 // parameters, duplicate parameters, trailing space, trailing alternate service
 // separator, etc.  Possibly multiple alternative service at a time.
 TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValueMultiple) {
   for (int i = 0; i < 1 << 11;) {
-    std::string header_field_value;
+    SpdyString header_field_value;
     SpdyAltSvcWireFormat::AlternativeServiceVector expected_altsvc_vector;
     // This will generate almost two hundred header field values with two,
     // three, four, five, six, and seven alternative services each, and
     // thousands with a single one.
     do {
       SpdyAltSvcWireFormat::AlternativeService expected_altsvc;
       FuzzHeaderFieldValue(i, &header_field_value, &expected_altsvc);
       expected_altsvc_vector.push_back(expected_altsvc);
       ++i;
     } while ((i < 1 << 13) && (i % 6 < i % 7));
     SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
     ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue(header_field_value,
                                                             &altsvc_vector));
     ASSERT_EQ(expected_altsvc_vector.size(), altsvc_vector.size());
     for (unsigned int j = 0; j < altsvc_vector.size(); ++j) {
       EXPECT_EQ(expected_altsvc_vector[j].protocol_id,
                 altsvc_vector[j].protocol_id);
       EXPECT_EQ(expected_altsvc_vector[j].host, altsvc_vector[j].host);
       EXPECT_EQ(expected_altsvc_vector[j].port, altsvc_vector[j].port);
       EXPECT_EQ(expected_altsvc_vector[j].max_age, altsvc_vector[j].max_age);
       EXPECT_EQ(expected_altsvc_vector[j].version, altsvc_vector[j].version);
     }
 
     // Roundtrip test starting with |altsvc_vector|.
-    std::string reserialized_header_field_value =
+    SpdyString reserialized_header_field_value =
         SpdyAltSvcWireFormat::SerializeHeaderFieldValue(altsvc_vector);
     SpdyAltSvcWireFormat::AlternativeServiceVector roundtrip_altsvc_vector;
     ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue(
         reserialized_header_field_value, &roundtrip_altsvc_vector));
     ASSERT_EQ(expected_altsvc_vector.size(), roundtrip_altsvc_vector.size());
     for (unsigned int j = 0; j < roundtrip_altsvc_vector.size(); ++j) {
       EXPECT_EQ(expected_altsvc_vector[j].protocol_id,
                 roundtrip_altsvc_vector[j].protocol_id);
       EXPECT_EQ(expected_altsvc_vector[j].host,
                 roundtrip_altsvc_vector[j].host);
@@ skipping 13 matching lines @@
             SpdyAltSvcWireFormat::SerializeHeaderFieldValue(altsvc_vector));
 }
 
 // Test ParseHeaderFieldValue() and SerializeHeaderFieldValue() on the same pair
 // of |expected_header_field_value| and |altsvc|, with and without hostname and
 // each
 // parameter.  Single alternative service at a time.
 TEST(SpdyAltSvcWireFormatTest, RoundTrip) {
   for (int i = 0; i < 1 << 3; ++i) {
     SpdyAltSvcWireFormat::AlternativeService altsvc;
-    std::string expected_header_field_value;
+    SpdyString expected_header_field_value;
     FuzzAlternativeService(i, &altsvc, &expected_header_field_value);
 
     // Test ParseHeaderFieldValue().
     SpdyAltSvcWireFormat::AlternativeServiceVector parsed_altsvc_vector;
     ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue(
         expected_header_field_value, &parsed_altsvc_vector));
     ASSERT_EQ(1u, parsed_altsvc_vector.size());
     EXPECT_EQ(altsvc.protocol_id, parsed_altsvc_vector[0].protocol_id);
     EXPECT_EQ(altsvc.host, parsed_altsvc_vector[0].host);
     EXPECT_EQ(altsvc.port, parsed_altsvc_vector[0].port);
     EXPECT_EQ(altsvc.max_age, parsed_altsvc_vector[0].max_age);
     EXPECT_EQ(altsvc.version, parsed_altsvc_vector[0].version);
 
     // Test SerializeHeaderFieldValue().
     SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
     altsvc_vector.push_back(altsvc);
     EXPECT_EQ(expected_header_field_value,
               SpdyAltSvcWireFormat::SerializeHeaderFieldValue(altsvc_vector));
   }
 }
 
 // Test ParseHeaderFieldValue() and SerializeHeaderFieldValue() on the same pair
 // of |expected_header_field_value| and |altsvc|, with and without hostname and
 // each
 // parameter.  Multiple alternative services at a time.
 TEST(SpdyAltSvcWireFormatTest, RoundTripMultiple) {
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
-  std::string expected_header_field_value;
+  SpdyString expected_header_field_value;
   for (int i = 0; i < 1 << 3; ++i) {
     SpdyAltSvcWireFormat::AlternativeService altsvc;
     FuzzAlternativeService(i, &altsvc, &expected_header_field_value);
     altsvc_vector.push_back(altsvc);
   }
 
   // Test ParseHeaderFieldValue().
   SpdyAltSvcWireFormat::AlternativeServiceVector parsed_altsvc_vector;
   ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue(
       expected_header_field_value, &parsed_altsvc_vector));
@@ skipping 51 matching lines @@
   }
 }
 
 // ParseHeaderFieldValue() should return false on a field values truncated
 // before closing quotation mark, without trying to access memory beyond the end
 // of the input.
 TEST(SpdyAltSvcWireFormatTest, ParseTruncatedHeaderFieldValue) {
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   const char* field_value_array[] = {"a=\":137\"", "a=\"foo:137\"",
                                      "a%25=\"foo\\\"bar\\\\baz:137\""};
-  for (const std::string& field_value : field_value_array) {
+  for (const SpdyString& field_value : field_value_array) {
     for (size_t len = 1; len < field_value.size(); ++len) {
       EXPECT_FALSE(SpdyAltSvcWireFormat::ParseHeaderFieldValue(
           field_value.substr(0, len), &altsvc_vector))
           << len;
     }
   }
 }
 
 // Tests of private methods.
 
 // Test SkipWhiteSpace().
 TEST(SpdyAltSvcWireFormatTest, SkipWhiteSpace) {
   SpdyStringPiece input("a \tb  ");
   SpdyStringPiece::const_iterator c = input.begin();
   test::SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end());
   ASSERT_EQ(input.begin(), c);
   ++c;
   test::SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end());
   ASSERT_EQ(input.begin() + 3, c);
   ++c;
   test::SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end());
   ASSERT_EQ(input.end(), c);
 }
 
 // Test PercentDecode() on valid input.
 TEST(SpdyAltSvcWireFormatTest, PercentDecodeValid) {
   SpdyStringPiece input("");
-  std::string output;
+  SpdyString output;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
       input.begin(), input.end(), &output));
   EXPECT_EQ("", output);
 
   input = SpdyStringPiece("foo");
   output.clear();
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
       input.begin(), input.end(), &output));
   EXPECT_EQ("foo", output);
 
   input = SpdyStringPiece("%2ca%5Cb");
   output.clear();
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
       input.begin(), input.end(), &output));
   EXPECT_EQ(",a\\b", output);
 }
 
 // Test PercentDecode() on invalid input.
 TEST(SpdyAltSvcWireFormatTest, PercentDecodeInvalid) {
   const char* invalid_input_array[] = {"a%", "a%x", "a%b", "%J22", "%9z"};
   for (const char* invalid_input : invalid_input_array) {
     SpdyStringPiece input(invalid_input);
-    std::string output;
+    SpdyString output;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
         input.begin(), input.end(), &output))
         << input;
   }
 }
 
 // Test ParseAltAuthority() on valid input.
 TEST(SpdyAltSvcWireFormatTest, ParseAltAuthorityValid) {
   SpdyStringPiece input(":42");
-  std::string host;
+  SpdyString host;
   uint16_t port;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
       input.begin(), input.end(), &host, &port));
   EXPECT_TRUE(host.empty());
   EXPECT_EQ(42, port);
 
   input = SpdyStringPiece("foo:137");
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
       input.begin(), input.end(), &host, &port));
   EXPECT_EQ("foo", host);
@@ skipping 20 matching lines @@
                                        " ",
                                        ":12 ",
                                        "foo:12 ",
                                        "[2003:8:0:16::509d:9615]",
                                        "[2003:8:0:16::509d:9615]:",
                                        "[2003:8:0:16::509d:9615]foo:443",
                                        "[2003:8:0:16::509d:9615:443",
                                        "2003:8:0:16::509d:9615]:443"};
   for (const char* invalid_input : invalid_input_array) {
     SpdyStringPiece input(invalid_input);
-    std::string host;
+    SpdyString host;
     uint16_t port;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
         input.begin(), input.end(), &host, &port))
         << input;
   }
 }
 
 // Test ParseInteger() on valid input.
 TEST(SpdyAltSvcWireFormatTest, ParseIntegerValid) {
   SpdyStringPiece input("3");
@@ skipping 73 matching lines @@
   EXPECT_EQ("quic", altsvc_vector[0].protocol_id);
   EXPECT_EQ("[2003:8:0:16::509d:9615]", altsvc_vector[0].host);
   EXPECT_EQ(443u, altsvc_vector[0].port);
   EXPECT_EQ(60u, altsvc_vector[0].max_age);
   EXPECT_THAT(altsvc_vector[0].version, ::testing::ElementsAre(36, 35));
 }
 
 }  // namespace
 
 }  // namespace net