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

net/spdy/hpack/hpack_encoder_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 "net/spdy/hpack/hpack_encoder.h"
 
 #include <map>
-#include <string>
 
 #include "base/rand_util.h"
 #include "net/base/arena.h"
 #include "net/spdy/hpack/hpack_huffman_table.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
-using std::string;
 using testing::ElementsAre;
 
 namespace test {
 
 class HpackHeaderTablePeer {
  public:
   explicit HpackHeaderTablePeer(HpackHeaderTable* table) : table_(table) {}
 
   HpackHeaderTable::EntryTable* dynamic_entries() {
     return &table_->dynamic_entries_;
@@ skipping 10 matching lines @@
 
   explicit HpackEncoderPeer(HpackEncoder* encoder) : encoder_(encoder) {}
 
   bool compression_enabled() const { return encoder_->enable_compression_; }
   HpackHeaderTable* table() { return &encoder_->header_table_; }
   HpackHeaderTablePeer table_peer() { return HpackHeaderTablePeer(table()); }
   const HpackHuffmanTable& huffman_table() const {
     return encoder_->huffman_table_;
   }
   void EmitString(SpdyStringPiece str) { encoder_->EmitString(str); }
-  void TakeString(string* out) { encoder_->output_stream_.TakeString(out); }
+  void TakeString(SpdyString* out) { encoder_->output_stream_.TakeString(out); }
   static void CookieToCrumbs(SpdyStringPiece cookie,
                              std::vector<SpdyStringPiece>* out) {
     Representations tmp;
     HpackEncoder::CookieToCrumbs(std::make_pair("", cookie), &tmp);
 
     out->clear();
     for (size_t i = 0; i != tmp.size(); ++i) {
       out->push_back(tmp[i].second);
     }
   }
   static void DecomposeRepresentation(SpdyStringPiece value,
                                       std::vector<SpdyStringPiece>* out) {
     Representations tmp;
     HpackEncoder::DecomposeRepresentation(std::make_pair("foobar", value),
                                           &tmp);
 
     out->clear();
     for (size_t i = 0; i != tmp.size(); ++i) {
       out->push_back(tmp[i].second);
     }
   }
 
   // TODO(dahollings): Remove or clean up these methods when deprecating
   // non-incremental encoding path.
   static bool EncodeHeaderSet(HpackEncoder* encoder,
                               const SpdyHeaderBlock& header_set,
-                              string* output,
+                              SpdyString* output,
                               bool use_incremental) {
     if (use_incremental) {
       return EncodeIncremental(encoder, header_set, output);
     } else {
       return encoder->EncodeHeaderSet(header_set, output);
     }
   }
 
   static bool EncodeIncremental(HpackEncoder* encoder,
                                 const SpdyHeaderBlock& header_set,
-                                string* output) {
+                                SpdyString* output) {
     std::unique_ptr<HpackEncoder::ProgressiveEncoder> encoderator =
         encoder->EncodeHeaderSet(header_set);
-    string output_buffer;
+    SpdyString output_buffer;
     encoderator->Next(base::RandInt(0, 15), &output_buffer);
     while (encoderator->HasNext()) {
-      string second_buffer;
+      SpdyString second_buffer;
       encoderator->Next(base::RandInt(0, 15), &second_buffer);
       output_buffer.append(second_buffer);
     }
     *output = std::move(output_buffer);
     return true;
   }
 
  private:
   HpackEncoder* encoder_;
 };
@@ skipping 73 matching lines @@
       expected_.AppendPrefix(kStringLiteralIdentityEncoded);
       expected_.AppendUint32(str.size());
       expected_.AppendBytes(str);
     }
   }
   void ExpectHeaderTableSizeUpdate(uint32_t size) {
     expected_.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     expected_.AppendUint32(size);
   }
   void CompareWithExpectedEncoding(const SpdyHeaderBlock& header_set) {
-    string expected_out, actual_out;
+    SpdyString expected_out, actual_out;
     expected_.TakeString(&expected_out);
     EXPECT_TRUE(test::HpackEncoderPeer::EncodeHeaderSet(
         &encoder_, header_set, &actual_out, use_incremental_));
     EXPECT_EQ(expected_out, actual_out);
   }
   size_t IndexOf(const HpackEntry* entry) {
     return peer_.table()->IndexOf(entry);
   }
 
   HpackEncoder encoder_;
@@ skipping 115 matching lines @@
   expected_.AppendPrefix(kStringLiteralHuffmanEncoded);
   expected_.AppendUint32(6);
   expected_.AppendBytes("\x94\xA5\x92\x32\x96_");
 
   // Non-compactable. Uses identity coding.
   peer_.EmitString("@@@@@@");
   expected_.AppendPrefix(kStringLiteralIdentityEncoded);
   expected_.AppendUint32(6);
   expected_.AppendBytes("@@@@@@");
 
-  string expected_out, actual_out;
+  SpdyString expected_out, actual_out;
   expected_.TakeString(&expected_out);
   peer_.TakeString(&actual_out);
   EXPECT_EQ(expected_out, actual_out);
 }
 
 TEST_P(HpackEncoderTest, EncodingWithoutCompression) {
   encoder_.SetHeaderListener(
       [this](SpdyStringPiece name, SpdyStringPiece value) {
         this->SaveHeaders(name, value);
       });
@@ skipping 168 matching lines @@
 
   peer.DecomposeRepresentation(SpdyStringPiece("\0foo\0bar\0", 9), &out);
   EXPECT_THAT(out, ElementsAre("", "foo", "bar", ""));
 }
 
 // Test that encoded headers do not have \0-delimited multiple values, as this
 // became disallowed in HTTP/2 draft-14.
 TEST_P(HpackEncoderTest, CrumbleNullByteDelimitedValue) {
   SpdyHeaderBlock headers;
   // A header field to be crumbled: "spam: foo\0bar".
-  headers["spam"] = string("foo\0bar", 7);
+  headers["spam"] = SpdyString("foo\0bar", 7);
 
   ExpectIndexedLiteral("spam", "foo");
   expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
   expected_.AppendUint32(62);
   expected_.AppendPrefix(kStringLiteralIdentityEncoded);
   expected_.AppendUint32(3);
   expected_.AppendBytes("bar");
   CompareWithExpectedEncoding(headers);
 }
 
@@ skipping 57 matching lines @@
   CompareWithExpectedEncoding(headers);
 
   HpackEntry* new_entry = &peer_.table_peer().dynamic_entries()->front();
   EXPECT_EQ(new_entry->name(), "key3");
   EXPECT_EQ(new_entry->value(), "value3");
 }
 
 }  // namespace
 
 }  // namespace net