Moves HpackEntry index computation into the container class HpackHeaderTable.

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 62 matching lines @@
         evictee->set_state(kNoState);
       }
     }
     if (entry != NULL) {
       EmitStaticIndex(entry);
     } else {
       EmitIndexedLiteral(*it);
     }
   }
   // Walk the reference set, toggling off as needed and clearing encoding state.
-  for (HpackEntry::OrderedSet::const_iterator it =
-          header_table_.reference_set().begin();
+  for (HpackHeaderTable::OrderedEntrySet::const_iterator it =
+           header_table_.reference_set().begin();
        it != header_table_.reference_set().end();) {
     HpackEntry* entry = *(it++);  // Step to prevent invalidation.
     CHECK_NE(kNoState, entry->state());
 
     if (entry->state() == kReferencedExplicitOff) {
       // Explicitly toggle off.
       EmitDynamicIndex(entry);
     }
     entry->set_state(kNoState);
   }
@@ skipping 12 matching lines @@
     EmitNonIndexedLiteral(*it);
   }
   allow_huffman_compression_ = true;
   output_stream_.TakeString(output);
   return true;
 }
 
 void HpackEncoder::EmitDynamicIndex(HpackEntry* entry) {
   DCHECK(!entry->IsStatic());
   output_stream_.AppendPrefix(kIndexedOpcode);
-  output_stream_.AppendUint32(entry->Index());
+  output_stream_.AppendUint32(header_table_.IndexOf(entry));
 
   entry->set_state(kNoState);
   if (header_table_.Toggle(entry)) {
     // Was added to the reference set.
     entry->set_state(kReferencedThisEncoding);
   }
 }
 
 void HpackEncoder::EmitStaticIndex(HpackEntry* entry) {
   DCHECK(entry->IsStatic());
   output_stream_.AppendPrefix(kIndexedOpcode);
-  output_stream_.AppendUint32(entry->Index());
+  output_stream_.AppendUint32(header_table_.IndexOf(entry));
 
   HpackEntry* new_entry = header_table_.TryAddEntry(entry->name(),
                                                     entry->value());
   if (new_entry) {
     // This is a static entry: no need to pin.
     header_table_.Toggle(new_entry);
     new_entry->set_state(kReferencedThisEncoding);
   }
 }
 
@@ skipping 13 matching lines @@
     const Representation& representation) {
   output_stream_.AppendPrefix(kLiteralNoIndexOpcode);
   output_stream_.AppendUint32(0);
   EmitString(representation.first);
   EmitString(representation.second);
 }
 
 void HpackEncoder::EmitLiteral(const Representation& representation) {
   const HpackEntry* name_entry = header_table_.GetByName(representation.first);
   if (name_entry != NULL) {
-    output_stream_.AppendUint32(name_entry->Index());
+    output_stream_.AppendUint32(header_table_.IndexOf(name_entry));
   } else {
     output_stream_.AppendUint32(0);
     EmitString(representation.first);
   }
   EmitString(representation.second);
 }
 
 void HpackEncoder::EmitString(StringPiece str) {
   size_t encoded_size = (!allow_huffman_compression_ ? str.size()
                          : huffman_table_.EncodedSize(str));
@@ skipping 22 matching lines @@
     } else {
       // Note std::map guarantees representations are ordered.
       full_set.push_back(make_pair(
           StringPiece(it->first), StringPiece(it->second)));
     }
   }
   // Perform a linear merge of ordered representations with the (also ordered)
   // reference set. Mark each referenced entry with current membership state,
   // and gather representations which must be explicitly emitted.
   Representations::const_iterator r_it = full_set.begin();
-  HpackEntry::OrderedSet::const_iterator s_it =
+  HpackHeaderTable::OrderedEntrySet::const_iterator s_it =
       header_table_.reference_set().begin();
 
   Representations explicit_set;
   while (r_it != full_set.end() &&
          s_it != header_table_.reference_set().end()) {
     // Compare on name, then value.
     int result = r_it->first.compare((*s_it)->name());
     if (result == 0) {
       result = r_it->second.compare((*s_it)->value());
     }
@@ skipping 65 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