HPACK optimal Huffman code instrumentation and UMA collection.

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 13 matching lines @@
 // Set on a referenced HpackEntry which is not part of the current header set.
 const uint8 kReferencedExplicitOff = 2;
 // Set on a entries added to the reference set during this encoding.
 const uint8 kReferencedThisEncoding = 3;
 
 }  // namespace
 
 HpackEncoder::HpackEncoder(const HpackHuffmanTable& table)
     : output_stream_(),
       allow_huffman_compression_(true),
-      huffman_table_(table) {}
+      huffman_table_(table),
+      char_counts_(NULL),
+      total_char_counts_(NULL) {}
 
 HpackEncoder::~HpackEncoder() {}
 
 bool HpackEncoder::EncodeHeaderSet(const std::map<string, string>& header_set,
                                    string* output) {
   // Walk the set of entries to encode, which are not already implied by the
   // header table's reference set. They must be explicitly emitted.
   Representations explicit_set(DetermineEncodingDelta(header_set));
   for (Representations::const_iterator it = explicit_set.begin();
        it != explicit_set.end(); ++it) {
@@ skipping 126 matching lines @@
                          : huffman_table_.EncodedSize(str));
   if (encoded_size < str.size()) {
     output_stream_.AppendPrefix(kStringLiteralHuffmanEncoded);
     output_stream_.AppendUint32(encoded_size);
     huffman_table_.EncodeString(str, &output_stream_);
   } else {
     output_stream_.AppendPrefix(kStringLiteralIdentityEncoded);
     output_stream_.AppendUint32(str.size());
     output_stream_.AppendBytes(str);
   }
+  UpdateCharacterCounts(str);
 }
 
 // static
 HpackEncoder::Representations HpackEncoder::DetermineEncodingDelta(
     const std::map<string, string>& header_set) {
   // Flatten & crumble headers into an ordered list of representations.
   Representations full_set;
   for (std::map<string, string>::const_iterator it = header_set.begin();
        it != header_set.end(); ++it) {
     if (it->first == "cookie") {
@@ skipping 39 matching lines @@
     explicit_set.push_back(*r_it);
     ++r_it;
   }
   while (s_it != header_table_.reference_set().end()) {
     (*s_it)->set_state(kReferencedExplicitOff);
     ++s_it;
   }
   return explicit_set;
 }
 
+void HpackEncoder::SetCharCountsStorage(std::vector<size_t>* char_counts,
+                                        size_t* total_char_counts) {
+  CHECK_LE(256u, char_counts->size());
+  char_counts_ = char_counts;
+  total_char_counts_ = total_char_counts;
+}
+
+void HpackEncoder::UpdateCharacterCounts(base::StringPiece str) {
+  if (char_counts_ == NULL || total_char_counts_ == NULL) {
+    return;
+  }
+  for (StringPiece::const_iterator it = str.begin(); it != str.end(); ++it) {
+    ++(*char_counts_)[static_cast<uint8>(*it)];
+  }
+  (*total_char_counts_) += str.size();
+}
+
 // static
 void HpackEncoder::CookieToCrumbs(const Representation& cookie,
                                   Representations* out) {
   // See Section 8.1.3.4 "Compressing the Cookie Header Field" in the HTTP/2
   // specification at http://tools.ietf.org/html/draft-ietf-httpbis-http2-11
   // Cookie values are split into individually-encoded HPACK representations.
   for (size_t pos = 0;;) {
     size_t end = cookie.second.find(";", pos);
 
     if (end == StringPiece::npos) {
       out->push_back(make_pair(
           cookie.first,
           cookie.second.substr(pos)));
       return;
     }
     out->push_back(make_pair(
         cookie.first,
         cookie.second.substr(pos, end - pos)));
 
     // Consume next space if present.
     pos = end + 1;
     if (pos != cookie.second.size() && cookie.second[pos] == ' ') {
       pos++;
     }
   }
 }
 
 }  // namespace net