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

net/spdy/hpack/hpack_encoder.h

 // 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.
 
 #ifndef NET_SPDY_HPACK_HPACK_ENCODER_H_
 #define NET_SPDY_HPACK_HPACK_ENCODER_H_
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
 #include "net/base/net_export.h"
 #include "net/spdy/hpack/hpack_header_table.h"
 #include "net/spdy/hpack/hpack_output_stream.h"
 #include "net/spdy/spdy_protocol.h"
 
+using base::StringPiece;

[Bence, 2016/08/15 13:58:31]

Please remove this using directive.  Unfortunately they are not allowed in
header files.  (See "Do not use Namespace aliases at namespace scope in header
files except in explicitly marked internal-only namespaces" and "Don't put
namespace aliases in your public" at
https://google.github.io/styleguide/cppguide.html.)  This means that in every
header file, we have to spell out base::StringPiece.

+
 // An HpackEncoder encodes header sets as outlined in
 // http://tools.ietf.org/html/rfc7541.
 
 namespace net {
 
 class HpackHuffmanTable;
 
 namespace test {
 class HpackEncoderPeer;
 }  // namespace test
 
 class NET_EXPORT_PRIVATE HpackEncoder {
  public:
   using Representation = std::pair<base::StringPiece, base::StringPiece>;
   using Representations = std::vector<Representation>;
 
+  // Callers may provide a HeaderListener to be informed of header name-value
+  // pairs processed by this encoder.
+  typedef std::function<void(StringPiece, StringPiece)> HeaderListener;
+
   // An indexing policy should return true if the provided header name-value
   // pair should be inserted into the HPACK dynamic table.
   using IndexingPolicy =
       std::function<bool(base::StringPiece, base::StringPiece)>;
 
   // |table| is an initialized HPACK Huffman table, having an
   // externally-managed lifetime which spans beyond HpackEncoder.
   explicit HpackEncoder(const HpackHuffmanTable& table);
   ~HpackEncoder();
 
@@ skipping 17 matching lines @@
   void ApplyHeaderTableSizeSetting(size_t size_setting);
 
   size_t CurrentHeaderTableSizeSetting() const {
     return header_table_.settings_size_bound();
   }
 
   // This HpackEncoder will use |policy| to determine whether to insert header
   // name-value pairs into the dynamic table.
   void SetIndexingPolicy(IndexingPolicy policy) { should_index_ = policy; }
 
+  // |listener| will be invoked for each header name-value pair processed by
+  // this encoder.
+  void SetHeaderListener(HeaderListener listener) { listener_ = listener; }
+
   void SetHeaderTableDebugVisitor(
       std::unique_ptr<HpackHeaderTable::DebugVisitorInterface> visitor) {
     header_table_.set_debug_visitor(std::move(visitor));
   }
 
  private:
   friend class test::HpackEncoderPeer;
 
   class RepresentationIterator;
 
@@ skipping 21 matching lines @@
 
   // Crumbles other header field values at \0 delimiters.
   static void DecomposeRepresentation(const Representation& header_field,
                                       Representations* out);
 
   HpackHeaderTable header_table_;
   HpackOutputStream output_stream_;
 
   const HpackHuffmanTable& huffman_table_;
   size_t min_table_size_setting_received_;
+  HeaderListener listener_;
   IndexingPolicy should_index_;
   bool allow_huffman_compression_;
   bool should_emit_table_size_;
 
   DISALLOW_COPY_AND_ASSIGN(HpackEncoder);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_HPACK_HPACK_ENCODER_H_