Adds a listener interface to HpackEncoder. Not used in production. Not protected.

net/spdy/hpack/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/hpack_encoder.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 38 matching lines @@
 
  private:
   Representations::const_iterator pseudo_begin_;
   Representations::const_iterator pseudo_end_;
   Representations::const_iterator regular_begin_;
   Representations::const_iterator regular_end_;
 };
 
 namespace {
 
+// The default header listener.
+void NoOpListener(StringPiece /*name*/, StringPiece /*value*/) {}
+
 // The default HPACK indexing policy.
 bool DefaultPolicy(StringPiece name, StringPiece /* value */) {
   if (name.empty()) {
     return false;
   }
   // :authority is always present and rarely changes, and has moderate
   // length, therefore it makes a lot of sense to index (insert in the
   // dynamic table).
   if (name[0] == kPseudoHeaderPrefix) {
     return name == ":authority";
   }
   return true;
 }
 
 }  // namespace
 
 HpackEncoder::HpackEncoder(const HpackHuffmanTable& table)
     : output_stream_(),
       huffman_table_(table),
       min_table_size_setting_received_(std::numeric_limits<size_t>::max()),
+      listener_(NoOpListener),
       should_index_(DefaultPolicy),
       allow_huffman_compression_(true),
       should_emit_table_size_(false) {}
 
 HpackEncoder::~HpackEncoder() {}
 
 void HpackEncoder::EncodeHeaderSet(const Representations& representations,
                                    string* output) {
   RepresentationIterator iter(representations);
   EncodeRepresentations(&iter, output);
@@ skipping 25 matching lines @@
   }
   return true;
 }
 
 bool HpackEncoder::EncodeHeaderSetWithoutCompression(
     const SpdyHeaderBlock& header_set,
     string* output) {
   allow_huffman_compression_ = false;
   MaybeEmitTableSize();
   for (const auto& header : header_set) {
+    listener_(header.first, header.second);
     // Note that cookies are not crumbled in this case.
     EmitNonIndexedLiteral(header);
   }
   allow_huffman_compression_ = true;
   output_stream_.TakeString(output);
   return true;
 }
 
 void HpackEncoder::ApplyHeaderTableSizeSetting(size_t size_setting) {
   if (size_setting == header_table_.settings_size_bound()) {
     return;
   }
   if (size_setting < header_table_.settings_size_bound()) {
     min_table_size_setting_received_ =
         std::min(size_setting, min_table_size_setting_received_);
   }
   header_table_.SetSettingsHeaderTableSize(size_setting);
   should_emit_table_size_ = true;
 }
 
 void HpackEncoder::EncodeRepresentations(RepresentationIterator* iter,
                                          string* output) {
   MaybeEmitTableSize();
   while (iter->HasNext()) {
     const auto header = iter->Next();
+    listener_(header.first, header.second);
     const HpackEntry* entry =
         header_table_.GetByNameAndValue(header.first, header.second);
     if (entry != nullptr) {
       EmitIndex(entry);
     } else if (should_index_(header.first, header.second)) {
       EmitIndexedLiteral(header);
     } else {
       EmitNonIndexedLiteral(header);
     }
   }
@@ skipping 105 matching lines @@
     end = header_field.second.find('\0', pos);
     out->push_back(
         std::make_pair(header_field.first,
                        header_field.second.substr(
                            pos, end == StringPiece::npos ? end : end - pos)));
     pos = end + 1;
   }
 }
 
 }  // namespace net