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

net/spdy/spdy_header_block.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_header_block.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/values.h"
 #include "net/base/arena.h"
 #include "net/http/http_log_util.h"
 #include "net/log/net_log_capture_mode.h"
 #include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
 #include "net/spdy/platform/api/spdy_string_utils.h"
 
-using std::string;
-
 namespace net {
 namespace {
 
 // By default, linked_hash_map's internal map allocates space for 100 map
 // buckets on construction, which is larger than necessary.  Standard library
 // unordered map implementations use a list of prime numbers to set the bucket
 // count for a particular capacity.  |kInitialMapBuckets| is chosen to reduce
 // memory usage for small header blocks, at the cost of having to rehash for
 // large header blocks.
 const size_t kInitialMapBuckets = 11;
@@ skipping 169 matching lines @@
                 key_, HeaderValue(storage_, key_, storage_->Write(value))))
             .first;
   } else {
     DVLOG(1) << "Updating key: " << key_ << " with value: " << value;
     lookup_result_->second =
         HeaderValue(storage_, key_, storage_->Write(value));
   }
   return *this;
 }
 
-string SpdyHeaderBlock::ValueProxy::as_string() const {
+SpdyString SpdyHeaderBlock::ValueProxy::as_string() const {
   if (lookup_result_ == block_->end()) {
     return "";
   } else {
-    return std::string(lookup_result_->second.value());
+    return SpdyString(lookup_result_->second.value());
   }
 }
 
 SpdyHeaderBlock::SpdyHeaderBlock() : block_(kInitialMapBuckets) {}
 
 SpdyHeaderBlock::SpdyHeaderBlock(SpdyHeaderBlock&& other) = default;
 
 SpdyHeaderBlock::~SpdyHeaderBlock() {}
 
 SpdyHeaderBlock& SpdyHeaderBlock::operator=(SpdyHeaderBlock&& other) {
@@ skipping 11 matching lines @@
 }
 
 bool SpdyHeaderBlock::operator==(const SpdyHeaderBlock& other) const {
   return size() == other.size() && std::equal(begin(), end(), other.begin());
 }
 
 bool SpdyHeaderBlock::operator!=(const SpdyHeaderBlock& other) const {
   return !(operator==(other));
 }
 
-string SpdyHeaderBlock::DebugString() const {
+SpdyString SpdyHeaderBlock::DebugString() const {
   if (empty()) {
     return "{}";
   }
 
-  string output = "\n{\n";
+  SpdyString output = "\n{\n";
   for (auto it = begin(); it != end(); ++it) {
     SpdyStrAppend(&output, "  ", it->first, " ", it->second, "\n");
   }
   SpdyStrAppend(&output, "}\n");
   return output;
 }
 
 void SpdyHeaderBlock::clear() {
   block_.clear();
   storage_.reset();
@@ skipping 90 matching lines @@
   const base::DictionaryValue* header_dict = NULL;
 
   if (!event_param ||
       !event_param->GetAsDictionary(&dict) ||
       !dict->GetDictionary("headers", &header_dict)) {
     return false;
   }
 
   for (base::DictionaryValue::Iterator it(*header_dict); !it.IsAtEnd();
        it.Advance()) {
-    string value;
+    SpdyString value;
     if (!it.value().GetAsString(&value)) {
       headers->clear();
       return false;
     }
     (*headers)[it.key()] = value;
   }
   return true;
 }
 
 size_t SpdyHeaderBlock::bytes_allocated() const {
@@ skipping 17 matching lines @@
   for (++it; it != fragments.end(); ++it) {
     memcpy(dst, separator.data(), separator.size());
     dst += separator.size();
     memcpy(dst, it->data(), it->size());
     dst += it->size();
   }
   return dst - original_dst;
 }
 
 }  // namespace net