Moves HpackEntry index computation into the container class HpackHeaderTable.

net/spdy/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_encoder.h"
 
 #include <map>
 #include <string>
 
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 94 matching lines @@
     // Disable Huffman coding by default. Most tests don't care about it.
     peer_.set_allow_huffman_compression(false);
   }
 
   void ExpectIndex(size_t index) {
     expected_.AppendPrefix(kIndexedOpcode);
     expected_.AppendUint32(index);
   }
   void ExpectIndexedLiteral(HpackEntry* key_entry, StringPiece value) {
     expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
-    expected_.AppendUint32(key_entry->Index());
+    expected_.AppendUint32(IndexOf(key_entry));
     expected_.AppendPrefix(kStringLiteralIdentityEncoded);
     expected_.AppendUint32(value.size());
     expected_.AppendBytes(value);
   }
   void ExpectIndexedLiteral(StringPiece name, StringPiece value) {
     expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
     expected_.AppendUint32(0);
     expected_.AppendPrefix(kStringLiteralIdentityEncoded);
     expected_.AppendUint32(name.size());
     expected_.AppendBytes(name);
@@ skipping 10 matching lines @@
     expected_.AppendPrefix(kStringLiteralIdentityEncoded);
     expected_.AppendUint32(value.size());
     expected_.AppendBytes(value);
   }
   void CompareWithExpectedEncoding(const map<string, string>& header_set) {
     string expected_out, actual_out;
     expected_.TakeString(&expected_out);
     EXPECT_TRUE(encoder_.EncodeHeaderSet(header_set, &actual_out));
     EXPECT_EQ(expected_out, actual_out);
   }
+  size_t IndexOf(HpackEntry* entry) {
+    return peer_.table()->IndexOf(entry);
+  }
 
   HpackEncoder encoder_;
   test::HpackEncoderPeer peer_;
 
   HpackEntry* static_;
   HpackEntry* key_1_;
   HpackEntry* key_2_;
   HpackEntry* cookie_a_;
   HpackEntry* cookie_c_;
 
   HpackOutputStream expected_;
 };
 
 TEST_F(HpackEncoderTest, SingleDynamicIndex) {
-  ExpectIndex(key_2_->Index());
+  ExpectIndex(IndexOf(key_2_));
 
   map<string, string> headers;
   headers[key_2_->name()] = key_2_->value();
   CompareWithExpectedEncoding(headers);
 
   // |key_2_| was added to the reference set.
   EXPECT_THAT(peer_.table()->reference_set(), ElementsAre(key_2_));
 }
 
 TEST_F(HpackEncoderTest, SingleStaticIndex) {
-  ExpectIndex(static_->Index());
+  ExpectIndex(IndexOf(static_));
 
   map<string, string> headers;
   headers[static_->name()] = static_->value();
   CompareWithExpectedEncoding(headers);
 
   // A new entry copying |static_| was inserted and added to the reference set.
   HpackEntry* new_entry = &peer_.table_peer().dynamic_entries()->front();
   EXPECT_NE(static_, new_entry);
   EXPECT_EQ(static_->name(), new_entry->name());
   EXPECT_EQ(static_->value(), new_entry->value());
   EXPECT_THAT(peer_.table()->reference_set(), ElementsAre(new_entry));
 }
 
 TEST_F(HpackEncoderTest, SingleStaticIndexTooLarge) {
   peer_.table()->SetMaxSize(1);  // Also evicts all fixtures.
-  ExpectIndex(static_->Index());
+  ExpectIndex(IndexOf(static_));
 
   map<string, string> headers;
   headers[static_->name()] = static_->value();
   CompareWithExpectedEncoding(headers);
 
   EXPECT_EQ(0u, peer_.table_peer().dynamic_entries()->size());
   EXPECT_EQ(0u, peer_.table()->reference_set().size());
 }
 
 TEST_F(HpackEncoderTest, SingleLiteralWithIndexName) {
@@ skipping 46 matching lines @@
   map<string, string> headers;
   headers[key_2_->name()] = key_2_->value();
   CompareWithExpectedEncoding(headers);
 }
 
 TEST_F(HpackEncoderTest, ExplicitToggleOff) {
   peer_.table()->Toggle(key_1_);
   peer_.table()->Toggle(key_2_);
 
   // |key_1_| is explicitly toggled off.
-  ExpectIndex(key_1_->Index());
+  ExpectIndex(IndexOf(key_1_));
 
   map<string, string> headers;
   headers[key_2_->name()] = key_2_->value();
   CompareWithExpectedEncoding(headers);
 }
 
 TEST_F(HpackEncoderTest, ImplicitToggleOff) {
   peer_.table()->Toggle(key_1_);
   peer_.table()->Toggle(key_2_);
 
   // |key_1_| is evicted. No explicit toggle required.
   ExpectIndexedLiteral("key3", "value3");
 
   map<string, string> headers;
   headers[key_2_->name()] = key_2_->value();
   headers["key3"] = "value3";
   CompareWithExpectedEncoding(headers);
 }
 
 TEST_F(HpackEncoderTest, ExplicitDoubleToggle) {
   peer_.table()->Toggle(key_1_);
 
   // |key_1_| is double-toggled prior to being evicted.
-  ExpectIndex(key_1_->Index());
-  ExpectIndex(key_1_->Index());
+  ExpectIndex(IndexOf(key_1_));
+  ExpectIndex(IndexOf(key_1_));
   ExpectIndexedLiteral("key3", "value3");
 
   map<string, string> headers;
   headers[key_1_->name()] = key_1_->value();
   headers["key3"] = "value3";
   CompareWithExpectedEncoding(headers);
 }
 
 TEST_F(HpackEncoderTest, EmitThanEvict) {
   // |key_1_| is toggled and placed into the reference set,
   // and then immediately evicted by "key3".
-  ExpectIndex(key_1_->Index());
+  ExpectIndex(IndexOf(key_1_));
   ExpectIndexedLiteral("key3", "value3");
 
   map<string, string> headers;
   headers[key_1_->name()] = key_1_->value();
   headers["key3"] = "value3";
   CompareWithExpectedEncoding(headers);
 }
 
 TEST_F(HpackEncoderTest, CookieHeaderIsCrumbled) {
   peer_.table()->Toggle(cookie_a_);
 
   // |cookie_a_| is already in the reference set. |cookie_c_| is
   // toggled, and "e=ff" is emitted with an indexed name.
-  ExpectIndex(cookie_c_->Index());
+  ExpectIndex(IndexOf(cookie_c_));
   ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "e=ff");
 
   map<string, string> headers;
   headers["cookie"] = "e=ff; a=bb; c=dd";
   CompareWithExpectedEncoding(headers);
 }
 
 TEST_F(HpackEncoderTest, StringsDynamicallySelectHuffmanCoding) {
   peer_.set_allow_huffman_compression(true);
 
@@ skipping 34 matching lines @@
   EXPECT_EQ(expected_out, actual_out);
 }
 
 TEST_F(HpackEncoderTest, MultipleEncodingPasses) {
   // Pass 1: key_1_ and cookie_a_ are toggled on.
   {
     map<string, string> headers;
     headers["key1"] = "value1";
     headers["cookie"] = "a=bb";
 
-    ExpectIndex(cookie_a_->Index());
-    ExpectIndex(key_1_->Index());
+    ExpectIndex(IndexOf(cookie_a_));
+    ExpectIndex(IndexOf(key_1_));
     CompareWithExpectedEncoding(headers);
   }
   // Pass 2: |key_1_| is double-toggled and evicted.
   // |key_2_| & |cookie_c_| are toggled on.
   // |cookie_a_| is toggled off.
   // A new cookie entry is added.
   {
     map<string, string> headers;
     headers["key1"] = "value1";
     headers["key2"] = "value2";
     headers["cookie"] = "c=dd; e=ff";
 
-    ExpectIndex(cookie_c_->Index());  // Toggle on.
-    ExpectIndex(key_1_->Index());  // Double-toggle before eviction.
-    ExpectIndex(key_1_->Index());
+    ExpectIndex(IndexOf(cookie_c_));  // Toggle on.
+    ExpectIndex(IndexOf(key_1_));  // Double-toggle before eviction.
+    ExpectIndex(IndexOf(key_1_));
     ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "e=ff");
-    ExpectIndex(key_2_->Index() + 1);  // Toggle on. Add 1 to reflect insertion.
-    ExpectIndex(cookie_a_->Index() + 1);  // Toggle off.
+
+    ExpectIndex(IndexOf(key_2_) + 1);  // Toggle on. Add 1 to reflect insertion.
+    ExpectIndex(IndexOf(cookie_a_) + 1);  // Toggle off.
     CompareWithExpectedEncoding(headers);
   }
   // Pass 3: |key_2_| is evicted and implicitly toggled off.
   // |cookie_c_| is explicitly toggled off.
   // "key1" is re-inserted.
   {
     map<string, string> headers;
     headers["key1"] = "value1";
     headers["key3"] = "value3";
     headers["cookie"] = "e=ff";
 
     ExpectIndexedLiteral("key1", "value1");
     ExpectIndexedLiteral("key3", "value3");
-    ExpectIndex(cookie_c_->Index() + 2);  // Toggle off. Add 1 for insertion.
+    ExpectIndex(IndexOf(cookie_c_) + 2);  // Toggle off. Add 1 for insertion.
 
     CompareWithExpectedEncoding(headers);
   }
 }
 
 TEST_F(HpackEncoderTest, CookieToCrumbs) {
   test::HpackEncoderPeer peer(NULL);
   std::vector<StringPiece> out;
 
   // A space after ';' is consumed. All other spaces remain. ';' at beginning
@@ skipping 36 matching lines @@
   expect[static_cast<uint8>('\xff')] = 1;
   expect[static_cast<uint8>('b')] = 1;
 
   EXPECT_EQ(expect, counts);
   EXPECT_EQ(9u, total_counts);
 }
 
 }  // namespace
 
 }  // namespace net