Make HPACK static table static and immutable.

net/spdy/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_encoder.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "net/spdy/hpack_header_table.h"
@@ skipping 30 matching lines @@
           StringPiece(it->first), StringPiece(it->second)));
     } else {
       regular_headers.push_back(make_pair(
           StringPiece(it->first), StringPiece(it->second)));
     }
   }
 
   // Encode pseudo-headers.
   for (Representations::const_iterator it = pseudo_headers.begin();
        it != pseudo_headers.end(); ++it) {
-    HpackEntry* entry = header_table_.GetByNameAndValue(it->first, it->second);
+    const HpackEntry* entry =
+        header_table_.GetByNameAndValue(it->first, it->second);
     if (entry != NULL) {
       EmitIndex(entry);
     } else {
       if (it->first == ":authority") {
         // :authority is always present and rarely changes, and has moderate
         // length, therefore it makes a lot of sense to index (insert in the
         // header table).
         EmitIndexedLiteral(*it);
       } else {
         // Most common pseudo-header fields are represented in the static table,
         // while uncommon ones are small, so do not index them.
         EmitNonIndexedLiteral(*it);
       }
     }
   }
 
   // Encode regular headers that are already in the header table first,
   // save the rest into another vector.  This way we avoid evicting an entry
   // from the header table before it can be used.
   Representations literal_headers;
   for (Representations::const_iterator it = regular_headers.begin();
        it != regular_headers.end(); ++it) {
-    HpackEntry* entry = header_table_.GetByNameAndValue(it->first, it->second);
+    const HpackEntry* entry =
+        header_table_.GetByNameAndValue(it->first, it->second);
     if (entry != NULL) {
       EmitIndex(entry);
     } else {
       literal_headers.push_back(*it);
     }
   }
 
   // Encode the remaining header fields, while inserting them in the header
   // table.
   for (Representations::const_iterator it = literal_headers.begin();
@@ skipping 13 matching lines @@
   for (std::map<string, string>::const_iterator it = header_set.begin();
        it != header_set.end(); ++it) {
     // Note that cookies are not crumbled in this case.
     EmitNonIndexedLiteral(*it);
   }
   allow_huffman_compression_ = true;
   output_stream_.TakeString(output);
   return true;
 }
 
-void HpackEncoder::EmitIndex(HpackEntry* entry) {
+void HpackEncoder::EmitIndex(const HpackEntry* entry) {
   output_stream_.AppendPrefix(kIndexedOpcode);
   output_stream_.AppendUint32(header_table_.IndexOf(entry));
 }
 
 void HpackEncoder::EmitIndexedLiteral(const Representation& representation) {
   output_stream_.AppendPrefix(kLiteralIncrementalIndexOpcode);
   EmitLiteral(representation);
   header_table_.TryAddEntry(representation.first, representation.second);
 }
 
@@ skipping 75 matching lines @@
       pos++;
     }
   }
   // Sort crumbs and remove duplicates.
   std::sort(out->begin() + prior_size, out->end());
   out->erase(std::unique(out->begin() + prior_size, out->end()),
              out->end());
 }
 
 }  // namespace net