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

net/spdy/spdy_http_utils.cc

 // Copyright (c) 2012 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_http_utils.h"
 
-#include <string>
-
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/url_util.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
+#include "net/spdy/platform/api/spdy_string.h"
 #include "net/spdy/platform/api/spdy_string_piece.h"
 
 namespace net {
 
 namespace {
 
-void AddSpdyHeader(const std::string& name,
-                   const std::string& value,
+void AddSpdyHeader(const SpdyString& name,
+                   const SpdyString& value,
                    SpdyHeaderBlock* headers) {
   if (headers->find(name) == headers->end()) {
     (*headers)[name] = value;
   } else {
-    std::string joint_value = (*headers)[name].as_string();
+    SpdyString joint_value = (*headers)[name].as_string();
     joint_value.append(1, '\0');
     joint_value.append(value);
     (*headers)[name] = joint_value;
   }
 }
 
 } // namespace
 
 bool SpdyHeadersToHttpResponse(const SpdyHeaderBlock& headers,
                                HttpResponseInfo* response) {
   // The ":status" header is required.
   SpdyHeaderBlock::const_iterator it = headers.find(":status");
   if (it == headers.end())
     return false;
-  std::string status = it->second.as_string();
-  std::string raw_headers("HTTP/1.1 ");
+  SpdyString status = it->second.as_string();
+  SpdyString raw_headers("HTTP/1.1 ");
   raw_headers.append(status);
   raw_headers.push_back('\0');
   for (it = headers.begin(); it != headers.end(); ++it) {
     // For each value, if the server sends a NUL-separated
     // list of values, we separate that back out into
     // individual headers for each value in the list.
     // e.g.
     //    Set-Cookie "foo\0bar"
     // becomes
     //    Set-Cookie: foo\0
     //    Set-Cookie: bar\0
-    std::string value = it->second.as_string();
+    SpdyString value = it->second.as_string();
     size_t start = 0;
     size_t end = 0;
     do {
       end = value.find('\0', start);
-      std::string tval;
+      SpdyString tval;
       if (end != value.npos)
         tval = value.substr(start, (end - start));
       else
         tval = value.substr(start);
       if (it->first[0] == ':')
         raw_headers.append(it->first.as_string().substr(1));
       else
         raw_headers.append(it->first.as_string());
       raw_headers.push_back(':');
       raw_headers.append(tval);
@@ skipping 15 matching lines @@
   if (info.method == "CONNECT") {
     (*headers)[":authority"] = GetHostAndPort(info.url);
   } else {
     (*headers)[":authority"] = GetHostAndOptionalPort(info.url);
     (*headers)[":scheme"] = info.url.scheme();
     (*headers)[":path"] = info.url.PathForRequest();
   }
 
   HttpRequestHeaders::Iterator it(request_headers);
   while (it.GetNext()) {
-    std::string name = base::ToLowerASCII(it.name());
+    SpdyString name = base::ToLowerASCII(it.name());
     if (name.empty() || name[0] == ':' || name == "connection" ||
         name == "proxy-connection" || name == "transfer-encoding" ||
         name == "host") {
       continue;
     }
     AddSpdyHeader(name, it.value(), headers);
   }
 }
 
 static_assert(HIGHEST - LOWEST < 4 && HIGHEST - MINIMUM_PRIORITY < 6,
@@ skipping 30 matching lines @@
     for (const auto& value : values) {
       http_headers->SetHeader(key, value);
     }
   }
 }
 
 GURL GetUrlFromHeaderBlock(const SpdyHeaderBlock& headers) {
   SpdyHeaderBlock::const_iterator it = headers.find(":scheme");
   if (it == headers.end())
     return GURL();
-  std::string url = it->second.as_string();
+  SpdyString url = it->second.as_string();
   url.append("://");
 
   it = headers.find(":authority");
   if (it == headers.end())
     return GURL();
   url.append(it->second.as_string());
 
   it = headers.find(":path");
   if (it == headers.end())
     return GURL();
   url.append(it->second.as_string());
   return GURL(url);
 }
 
 }  // namespace net