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

net/spdy/hpack/hpack_round_trip_test.cc

 // Copyright 2014 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 <cmath>
 #include <ctime>
-#include <string>
 #include <vector>
 
 #include "base/rand_util.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/hpack/hpack_decoder.h"
 #include "net/spdy/hpack/hpack_encoder.h"
+#include "net/spdy/platform/api/spdy_string.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 
-using std::string;
-
 namespace {
 
 // Supports testing with the input split at every byte boundary.
 enum InputSizeParam { ALL_INPUT, ONE_BYTE, ZERO_THEN_ONE_BYTE };
 
 class HpackRoundTripTest : public ::testing::TestWithParam<InputSizeParam> {
  protected:
   HpackRoundTripTest() : encoder_(ObtainHpackHuffmanTable()), decoder_() {}
 
   void SetUp() override {
     // Use a small table size to tickle eviction handling.
     encoder_.ApplyHeaderTableSizeSetting(256);
     decoder_.ApplyHeaderTableSizeSetting(256);
   }
 
   bool RoundTrip(const SpdyHeaderBlock& header_set) {
-    string encoded;
+    SpdyString encoded;
     encoder_.EncodeHeaderSet(header_set, &encoded);
 
     bool success = true;
     if (GetParam() == ALL_INPUT) {
       // Pass all the input to the decoder at once.
       success = decoder_.HandleControlFrameHeadersData(encoded.data(),
                                                        encoded.size());
     } else if (GetParam() == ONE_BYTE) {
       // Pass the input to the decoder one byte at a time.
       const char* data = encoded.data();
@@ skipping 54 matching lines @@
   {
     SpdyHeaderBlock headers;
     headers[":status"] = "200";
     headers["cache-control"] = "private";
     headers["content-encoding"] = "gzip";
     headers["date"] = "Mon, 21 Oct 2013 20:13:22 GMT";
     headers["location"] = "https://www.example.com";
     headers["set-cookie"] =
         "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;"
         " max-age=3600; version=1";
-    headers["multivalue"] = string("foo\0bar", 7);
+    headers["multivalue"] = SpdyString("foo\0bar", 7);
     EXPECT_TRUE(RoundTrip(headers));
   }
 }
 
 TEST_P(HpackRoundTripTest, RequestFixtures) {
   {
     SpdyHeaderBlock headers;
     headers[":authority"] = "www.example.com";
     headers[":method"] = "GET";
     headers[":path"] = "/";
@@ skipping 12 matching lines @@
     EXPECT_TRUE(RoundTrip(headers));
   }
   {
     SpdyHeaderBlock headers;
     headers[":authority"] = "www.example.com";
     headers[":method"] = "GET";
     headers[":path"] = "/index.html";
     headers[":scheme"] = "https";
     headers["custom-key"] = "custom-value";
     headers["cookie"] = "baz=bing; fizzle=fazzle; garbage";
-    headers["multivalue"] = string("foo\0bar", 7);
+    headers["multivalue"] = SpdyString("foo\0bar", 7);
     EXPECT_TRUE(RoundTrip(headers));
   }
 }
 
 TEST_P(HpackRoundTripTest, RandomizedExamples) {
   // Grow vectors of names & values, which are seeded with fixtures and then
   // expanded with dynamically generated data. Samples are taken using the
   // exponential distribution.
-  std::vector<string> pseudo_header_names, random_header_names;
+  std::vector<SpdyString> pseudo_header_names, random_header_names;
   pseudo_header_names.push_back(":authority");
   pseudo_header_names.push_back(":path");
   pseudo_header_names.push_back(":status");
 
   // TODO(jgraettinger): Enable "cookie" as a name fixture. Crumbs may be
   // reconstructed in any order, which breaks the simple validation used here.
 
-  std::vector<string> values;
+  std::vector<SpdyString> values;
   values.push_back("/");
   values.push_back("/index.html");
   values.push_back("200");
   values.push_back("404");
   values.push_back("");
   values.push_back("baz=bing; foo=bar; garbage");
   values.push_back("baz=bing; fizzle=fazzle; garbage");
 
   int seed = std::time(NULL);
   LOG(INFO) << "Seeding with srand(" << seed << ")";
   srand(seed);
 
   for (size_t i = 0; i != 2000; ++i) {
     SpdyHeaderBlock headers;
 
     // Choose a random number of headers to add, and of these a random subset
     // will be HTTP/2 pseudo headers.
     size_t header_count = 1 + SampleExponential(7, 50);
     size_t pseudo_header_count =
         std::min(header_count, 1 + SampleExponential(7, 50));
     EXPECT_LE(pseudo_header_count, header_count);
     for (size_t j = 0; j != header_count; ++j) {
-      string name, value;
+      SpdyString name, value;
       // Pseudo headers must be added before regular headers.
       if (j < pseudo_header_count) {
         // Choose one of the defined pseudo headers at random.
         size_t name_index = base::RandGenerator(pseudo_header_names.size());
         name = pseudo_header_names[name_index];
       } else {
         // Randomly reuse an existing header name, or generate a new one.
         size_t name_index = SampleExponential(20, 200);
         if (name_index >= random_header_names.size()) {
           name = base::RandBytesAsString(1 + SampleExponential(5, 30));
           // A regular header cannot begin with the pseudo header prefix ":".
           if (name[0] == ':') {
             name[0] = 'x';
           }
           random_header_names.push_back(name);
         } else {
           name = random_header_names[name_index];
         }
       }
 
       // Randomly reuse an existing value, or generate a new one.
       size_t value_index = SampleExponential(20, 200);
       if (value_index >= values.size()) {
-        string newvalue =
+        SpdyString newvalue =
             base::RandBytesAsString(1 + SampleExponential(15, 75));
         // Currently order is not preserved in the encoder.  In particular,
         // when a value is decomposed at \0 delimiters, its parts might get
         // encoded out of order if some but not all of them already exist in
         // the header table.  For now, avoid \0 bytes in values.
         std::replace(newvalue.begin(), newvalue.end(), '\x00', '\x01');
         values.push_back(newvalue);
         value = values.back();
       } else {
         value = values[value_index];
       }
       headers[name] = value;
     }
     EXPECT_TRUE(RoundTrip(headers));
   }
 }
 
 }  // namespace
 
 }  // namespace test
 }  // namespace net