Make HPACK static table static and immutable.

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 70 matching lines @@
 
 using std::map;
 using testing::ElementsAre;
 
 class HpackEncoderTest : public ::testing::Test {
  protected:
   typedef test::HpackEncoderPeer::Representations Representations;
 
   HpackEncoderTest()
       : encoder_(ObtainHpackHuffmanTable()),
-        peer_(&encoder_) {}
+        peer_(&encoder_),
+        static_(peer_.table()->GetByIndex(1)) {}
 
   virtual void SetUp() {
-    static_ = peer_.table()->GetByIndex(1);
     // Populate dynamic entries into the table fixture. For simplicity each
     // entry has name.size() + value.size() == 10.
     key_1_ = peer_.table()->TryAddEntry("key1", "value1");
     key_2_ = peer_.table()->TryAddEntry("key2", "value2");
     cookie_a_ = peer_.table()->TryAddEntry("cookie", "a=bb");
     cookie_c_ = peer_.table()->TryAddEntry("cookie", "c=dd");
 
     // No further insertions may occur without evictions.
     peer_.table()->SetMaxSize(peer_.table()->size());
 
     // 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) {
+  void ExpectIndexedLiteral(const HpackEntry* key_entry, StringPiece value) {
     expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
     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);
@@ skipping 15 matching lines @@
   }
   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);
   }
+  size_t IndexOf(const 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_;
+  const HpackEntry* static_;
+  const HpackEntry* key_1_;
+  const HpackEntry* key_2_;
+  const HpackEntry* cookie_a_;
+  const HpackEntry* cookie_c_;
 
   HpackOutputStream expected_;
 };
 
 TEST_F(HpackEncoderTest, SingleDynamicIndex) {
   ExpectIndex(IndexOf(key_2_));
 
   map<string, string> headers;
   headers[key_2_->name()] = key_2_->value();
   CompareWithExpectedEncoding(headers);
@@ skipping 241 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