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

net/spdy/spdy_alt_svc_wire_format.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 <algorithm>
 #include <cctype>
 #include <limits>
-#include <string>
 
 #include "base/logging.h"
 #include "net/spdy/platform/api/spdy_string_utils.h"
 
 namespace net {
 
 namespace {
 
 template <class T>
 bool ParsePositiveIntegerImpl(SpdyStringPiece::const_iterator c,
@@ skipping 11 matching lines @@
     *value += *c - '0';
   }
   return (c == end && *value > 0);
 }
 
 }  // namespace
 
 SpdyAltSvcWireFormat::AlternativeService::AlternativeService() {}
 
 SpdyAltSvcWireFormat::AlternativeService::AlternativeService(
-    const std::string& protocol_id,
-    const std::string& host,
+    const SpdyString& protocol_id,
+    const SpdyString& host,
     uint16_t port,
     uint32_t max_age,
     VersionVector version)
     : protocol_id(protocol_id),
       host(host),
       port(port),
       max_age(max_age),
       version(version) {}
 
 SpdyAltSvcWireFormat::AlternativeService::~AlternativeService() {}
@@ skipping 11 matching lines @@
   }
   altsvc_vector->clear();
   if (value == SpdyStringPiece("clear")) {
     return true;
   }
   SpdyStringPiece::const_iterator c = value.begin();
   while (c != value.end()) {
     // Parse protocol-id.
     SpdyStringPiece::const_iterator percent_encoded_protocol_id_end =
         std::find(c, value.end(), '=');
-    std::string protocol_id;
+    SpdyString protocol_id;
     if (percent_encoded_protocol_id_end == c ||
         !PercentDecode(c, percent_encoded_protocol_id_end, &protocol_id)) {
       return false;
     }
     c = percent_encoded_protocol_id_end;
     if (c == value.end()) {
       return false;
     }
     // Parse alt-authority.
     DCHECK_EQ('=', *c);
@@ skipping 10 matching lines @@
       }
       ++c;
       if (c == value.end()) {
         return false;
       }
     }
     if (c == alt_authority_begin || c == value.end()) {
       return false;
     }
     DCHECK_EQ('"', *c);
-    std::string host;
+    SpdyString host;
     uint16_t port;
     if (!ParseAltAuthority(alt_authority_begin, c, &host, &port)) {
       return false;
     }
     ++c;
     // Parse parameters.
     uint32_t max_age = 86400;
     VersionVector version;
     SpdyStringPiece::const_iterator parameters_end =
         std::find(c, value.end(), ',');
     while (c != parameters_end) {
       SkipWhiteSpace(&c, parameters_end);
       if (c == parameters_end) {
         break;
       }
       if (*c != ';') {
         return false;
       }
       ++c;
       SkipWhiteSpace(&c, parameters_end);
       if (c == parameters_end) {
         break;
       }
-      std::string parameter_name;
+      SpdyString parameter_name;
       for (; c != parameters_end && *c != '=' && *c != ' ' && *c != '\t'; ++c) {
         parameter_name.push_back(tolower(*c));
       }
       SkipWhiteSpace(&c, parameters_end);
       if (c == parameters_end || *c != '=') {
         return false;
       }
       ++c;
       SkipWhiteSpace(&c, parameters_end);
       SpdyStringPiece::const_iterator parameter_value_begin = c;
@@ skipping 40 matching lines @@
       }
     }
     altsvc_vector->emplace_back(protocol_id, host, port, max_age, version);
     for (; c != value.end() && (*c == ' ' || *c == '\t' || *c == ','); ++c) {
     }
   }
   return true;
 }
 
 // static
-std::string SpdyAltSvcWireFormat::SerializeHeaderFieldValue(
+SpdyString SpdyAltSvcWireFormat::SerializeHeaderFieldValue(
     const AlternativeServiceVector& altsvc_vector) {
   if (altsvc_vector.empty()) {
-    return std::string("clear");
+    return SpdyString("clear");
   }
   const char kNibbleToHex[] = "0123456789ABCDEF";
-  std::string value;
+  SpdyString value;
   for (const AlternativeService& altsvc : altsvc_vector) {
     if (!value.empty()) {
       value.push_back(',');
     }
     // Percent escape protocol id according to
     // http://tools.ietf.org/html/rfc7230#section-3.2.6.
     for (char c : altsvc.protocol_id) {
       if (isalnum(c)) {
         value.push_back(c);
         continue;
@@ skipping 53 matching lines @@
 // static
 void SpdyAltSvcWireFormat::SkipWhiteSpace(SpdyStringPiece::const_iterator* c,
                                           SpdyStringPiece::const_iterator end) {
   for (; *c != end && (**c == ' ' || **c == '\t'); ++*c) {
   }
 }
 
 // static
 bool SpdyAltSvcWireFormat::PercentDecode(SpdyStringPiece::const_iterator c,
                                          SpdyStringPiece::const_iterator end,
-                                         std::string* output) {
+                                         SpdyString* output) {
   output->clear();
   for (; c != end; ++c) {
     if (*c != '%') {
       output->push_back(*c);
       continue;
     }
     DCHECK_EQ('%', *c);
     ++c;
     if (c == end || !std::isxdigit(*c)) {
       return false;
     }
     // Network byte order is big-endian.
     char decoded = SpdyHexDigitToInt(*c) << 4;
     ++c;
     if (c == end || !std::isxdigit(*c)) {
       return false;
     }
     decoded += SpdyHexDigitToInt(*c);
     output->push_back(decoded);
   }
   return true;
 }
 
 // static
 bool SpdyAltSvcWireFormat::ParseAltAuthority(
     SpdyStringPiece::const_iterator c,
     SpdyStringPiece::const_iterator end,
-    std::string* host,
+    SpdyString* host,
     uint16_t* port) {
   host->clear();
   if (c == end) {
     return false;
   }
   if (*c == '[') {
     for (; c != end && *c != ']'; ++c) {
       if (*c == '"') {
         // Port is mandatory.
         return false;
@@ skipping 39 matching lines @@
 
 // static
 bool SpdyAltSvcWireFormat::ParsePositiveInteger32(
     SpdyStringPiece::const_iterator c,
     SpdyStringPiece::const_iterator end,
     uint32_t* value) {
   return ParsePositiveIntegerImpl<uint32_t>(c, end, value);
 }
 
 }  // namespace net