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

net/spdy/hpack/hpack_encoder.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 "net/spdy/hpack/hpack_encoder.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/hpack/hpack_header_table.h"
 #include "net/spdy/hpack/hpack_huffman_table.h"
 #include "net/spdy/hpack/hpack_output_stream.h"
 #include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
 
 namespace net {
 
-using std::string;
-
 class HpackEncoder::RepresentationIterator {
  public:
   // |pseudo_headers| and |regular_headers| must outlive the iterator.
   RepresentationIterator(const Representations& pseudo_headers,
                          const Representations& regular_headers)
       : pseudo_begin_(pseudo_headers.begin()),
         pseudo_end_(pseudo_headers.end()),
         regular_begin_(regular_headers.begin()),
         regular_end_(regular_headers.end()) {}
 
@@ skipping 49 matching lines @@
       huffman_table_(table),
       min_table_size_setting_received_(std::numeric_limits<size_t>::max()),
       listener_(NoOpListener),
       should_index_(DefaultPolicy),
       enable_compression_(true),
       should_emit_table_size_(false) {}
 
 HpackEncoder::~HpackEncoder() {}
 
 void HpackEncoder::EncodeHeaderSet(const Representations& representations,
-                                   string* output) {
+                                   SpdyString* output) {
   RepresentationIterator iter(representations);
   EncodeRepresentations(&iter, output);
 }
 
 bool HpackEncoder::EncodeHeaderSet(const SpdyHeaderBlock& header_set,
-                                   string* output) {
+                                   SpdyString* output) {
   // Separate header set into pseudo-headers and regular headers.
   Representations pseudo_headers;
   Representations regular_headers;
   bool found_cookie = false;
   for (const auto& header : header_set) {
     if (!found_cookie && header.first == "cookie") {
       // Note that there can only be one "cookie" header, because header_set is
       // a map.
       found_cookie = true;
       CookieToCrumbs(header, &regular_headers);
@@ skipping 24 matching lines @@
   should_emit_table_size_ = true;
 }
 
 size_t HpackEncoder::EstimateMemoryUsage() const {
   // |huffman_table_| is a singleton. It's accounted for in spdy_session_pool.cc
   return SpdyEstimateMemoryUsage(header_table_) +
          SpdyEstimateMemoryUsage(output_stream_);
 }
 
 void HpackEncoder::EncodeRepresentations(RepresentationIterator* iter,
-                                         string* output) {
+                                         SpdyString* output) {
   MaybeEmitTableSize();
   while (iter->HasNext()) {
     const auto header = iter->Next();
     listener_(header.first, header.second);
     if (enable_compression_) {
       const HpackEntry* entry =
           header_table_.GetByNameAndValue(header.first, header.second);
       if (entry != nullptr) {
         EmitIndex(entry);
       } else if (should_index_(header.first, header.second)) {
@@ skipping 138 matching lines @@
 
   // Encoderator is neither copyable nor movable.
   Encoderator(const Encoderator&) = delete;
   Encoderator& operator=(const Encoderator&) = delete;
 
   // Returns true iff more remains to encode.
   bool HasNext() const override { return has_next_; }
 
   // Encodes up to max_encoded_bytes of the current header block into the
   // given output string.
-  void Next(size_t max_encoded_bytes, string* output) override;
+  void Next(size_t max_encoded_bytes, SpdyString* output) override;
 
  private:
   HpackEncoder* encoder_;
   std::unique_ptr<RepresentationIterator> header_it_;
   Representations pseudo_headers_;
   Representations regular_headers_;
   bool has_next_;
 };
 
 HpackEncoder::Encoderator::Encoderator(const SpdyHeaderBlock& header_set,
@@ skipping 16 matching lines @@
       use_compression ? DecomposeRepresentation(header, &regular_headers_)
                       : GatherRepresentation(header, &regular_headers_);
     }
   }
   header_it_ = base::MakeUnique<RepresentationIterator>(pseudo_headers_,
                                                         regular_headers_);
 
   encoder_->MaybeEmitTableSize();
 }
 
-void HpackEncoder::Encoderator::Next(size_t max_encoded_bytes, string* output) {
+void HpackEncoder::Encoderator::Next(size_t max_encoded_bytes,
+                                     SpdyString* output) {
   SPDY_BUG_IF(!has_next_)
       << "Encoderator::Next called with nothing left to encode.";
   const bool use_compression = encoder_->enable_compression_;
 
   // Encode up to max_encoded_bytes of headers.
   while (header_it_->HasNext() &&
          encoder_->output_stream_.size() <= max_encoded_bytes) {
     const Representation header = header_it_->Next();
     encoder_->listener_(header.first, header.second);
     if (use_compression) {
@@ skipping 14 matching lines @@
   has_next_ = encoder_->output_stream_.size() > max_encoded_bytes;
   encoder_->output_stream_.BoundedTakeString(max_encoded_bytes, output);
 }
 
 std::unique_ptr<HpackEncoder::ProgressiveEncoder> HpackEncoder::EncodeHeaderSet(
     const SpdyHeaderBlock& header_set) {
   return base::MakeUnique<Encoderator>(header_set, this);
 }
 
 }  // namespace net