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

net/spdy/hpack/hpack_header_table_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_header_table.h"
 
 #include <algorithm>
 #include <set>
-#include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/hpack/hpack_entry.h"
+#include "net/spdy/platform/api/spdy_string.h"
 #include "net/spdy/spdy_flags.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 using std::distance;
-using std::string;
 
 namespace test {
 
 class HpackHeaderTablePeer {
  public:
   explicit HpackHeaderTablePeer(HpackHeaderTable* table) : table_(table) {}
 
   const HpackHeaderTable::EntryTable& dynamic_entries() {
     return table_->dynamic_entries_;
   }
@@ skipping 38 matching lines @@
 
 class HpackHeaderTableTest : public ::testing::Test {
  protected:
   typedef std::vector<HpackEntry> HpackEntryVector;
 
   HpackHeaderTableTest() : table_(), peer_(&table_) {}
 
   // Returns an entry whose Size() is equal to the given one.
   static HpackEntry MakeEntryOfSize(uint32_t size) {
     EXPECT_GE(size, HpackEntry::kSizeOverhead);
-    string name((size - HpackEntry::kSizeOverhead) / 2, 'n');
-    string value(size - HpackEntry::kSizeOverhead - name.size(), 'v');
+    SpdyString name((size - HpackEntry::kSizeOverhead) / 2, 'n');
+    SpdyString value(size - HpackEntry::kSizeOverhead - name.size(), 'v');
     HpackEntry entry(name, value, false, 0);
     EXPECT_EQ(size, entry.Size());
     return entry;
   }
 
   // Returns a vector of entries whose total size is equal to the given
   // one.
   static HpackEntryVector MakeEntriesOfTotalSize(uint32_t total_size) {
     EXPECT_GE(total_size, HpackEntry::kSizeOverhead);
     uint32_t entry_size = HpackEntry::kSizeOverhead;
@@ skipping 25 matching lines @@
     for (size_t i = 0; i != entries.size(); ++i) {
       // Static table has 61 entries, dynamic entries follow those.
       size_t index = 61 + entries.size() - i;
       const HpackEntry* entry = table_.GetByIndex(index);
       EXPECT_EQ(entries[i].name(), entry->name());
       EXPECT_EQ(entries[i].value(), entry->value());
       EXPECT_EQ(index, table_.IndexOf(entry));
     }
   }
 
-  HpackEntry DynamicEntry(const string& name, const string& value) {
+  HpackEntry DynamicEntry(const SpdyString& name, const SpdyString& value) {
     peer_.AddDynamicEntry(name, value);
     return peer_.dynamic_entries().back();
   }
 
   HpackHeaderTable table_;
   test::HpackHeaderTablePeer peer_;
 };
 
 TEST_F(HpackHeaderTableTest, StaticTableInitialization) {
   EXPECT_EQ(0u, table_.size());
@@ skipping 114 matching lines @@
   EXPECT_EQ(entry2,
             table_.GetByNameAndValue(first_static_entry->name(), "Value Four"));
 
   // Evict |entry2|. Queries by its name & value are not found.
   peer_.Evict(1);
   EXPECT_EQ(NULL,
             table_.GetByNameAndValue(first_static_entry->name(), "Value Four"));
 }
 
 TEST_F(HpackHeaderTableTest, SetSizes) {
-  string key = "key", value = "value";
+  SpdyString key = "key", value = "value";
   const HpackEntry* entry1 = table_.TryAddEntry(key, value);
   const HpackEntry* entry2 = table_.TryAddEntry(key, value);
   const HpackEntry* entry3 = table_.TryAddEntry(key, value);
 
   // Set exactly large enough. No Evictions.
   size_t max_size = entry1->Size() + entry2->Size() + entry3->Size();
   table_.SetMaxSize(max_size);
   EXPECT_EQ(3u, peer_.dynamic_entries().size());
 
   // Set just too small. One eviction.
@@ skipping 11 matching lines @@
   // SETTINGS_HEADER_TABLE_SIZE upper-bounds |table_.max_size()|,
   // and will force evictions.
   max_size = entry3->Size() - 1;
   table_.SetSettingsHeaderTableSize(max_size);
   EXPECT_EQ(max_size, table_.max_size());
   EXPECT_EQ(max_size, table_.settings_size_bound());
   EXPECT_EQ(0u, peer_.dynamic_entries().size());
 }
 
 TEST_F(HpackHeaderTableTest, EvictionCountForEntry) {
-  string key = "key", value = "value";
+  SpdyString key = "key", value = "value";
   const HpackEntry* entry1 = table_.TryAddEntry(key, value);
   const HpackEntry* entry2 = table_.TryAddEntry(key, value);
   size_t entry3_size = HpackEntry::Size(key, value);
 
   // Just enough capacity for third entry.
   table_.SetMaxSize(entry1->Size() + entry2->Size() + entry3_size);
   EXPECT_EQ(0u, peer_.EvictionCountForEntry(key, value));
   EXPECT_EQ(1u, peer_.EvictionCountForEntry(key, value + "x"));
 
   // No extra capacity. Third entry would force evictions.
   table_.SetMaxSize(entry1->Size() + entry2->Size());
   EXPECT_EQ(1u, peer_.EvictionCountForEntry(key, value));
   EXPECT_EQ(2u, peer_.EvictionCountForEntry(key, value + "x"));
 }
 
 TEST_F(HpackHeaderTableTest, EvictionCountToReclaim) {
-  string key = "key", value = "value";
+  SpdyString key = "key", value = "value";
   const HpackEntry* entry1 = table_.TryAddEntry(key, value);
   const HpackEntry* entry2 = table_.TryAddEntry(key, value);
 
   EXPECT_EQ(1u, peer_.EvictionCountToReclaim(1));
   EXPECT_EQ(1u, peer_.EvictionCountToReclaim(entry1->Size()));
   EXPECT_EQ(2u, peer_.EvictionCountToReclaim(entry1->Size() + 1));
   EXPECT_EQ(2u, peer_.EvictionCountToReclaim(entry1->Size() + entry2->Size()));
 }
 
 // Fill a header table with entries. Make sure the entries are in
@@ skipping 118 matching lines @@
   HpackHeaderTable::EntryHasher hasher;
   EXPECT_EQ(hasher(&entry1), hasher(&entry2));
 
   HpackHeaderTable::EntriesEq eq;
   EXPECT_TRUE(eq(&entry1, &entry2));
 }
 
 }  // namespace
 
 }  // namespace net