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

net/spdy/hpack/hpack_encoder_test.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 <map>
 #include <string>
 
+#include "net/base/arena.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 using base::StringPiece;
 using std::string;
+using std::vector;
+using std::pair;
 using testing::ElementsAre;
 
 namespace test {
 
 class HpackHeaderTablePeer {
  public:
   explicit HpackHeaderTablePeer(HpackHeaderTable* table) : table_(table) {}
 
   HpackHeaderTable::EntryTable* dynamic_entries() {
     return &table_->dynamic_entries_;
@@ skipping 42 matching lines @@
  private:
   HpackEncoder* encoder_;
 };
 
 }  // namespace test
 
 namespace {
 
 using std::map;
 using testing::ElementsAre;
+using testing::Pair;
 
 class HpackEncoderTest : public ::testing::Test {
  protected:
   typedef test::HpackEncoderPeer::Representations Representations;
 
   HpackEncoderTest()
       : encoder_(ObtainHpackHuffmanTable()),
         peer_(&encoder_),
-        static_(peer_.table()->GetByIndex(1)) {}
+        static_(peer_.table()->GetByIndex(1)),
+        headers_storage_(1024 /* block size */) {}
 
   void SetUp() override {
     // Populate dynamic entries into the table fixture. For simplicity each
     // entry has name.size() + value.size() == 10.
     key_1_ = peer_.table()->TryAddEntry("key1", "value1");
     key_2_ = peer_.table()->TryAddEntry("key2", "value2");
     cookie_a_ = peer_.table()->TryAddEntry("cookie", "a=bb");
     cookie_c_ = peer_.table()->TryAddEntry("cookie", "c=dd");
 
     // No further insertions may occur without evictions.
     peer_.table()->SetMaxSize(peer_.table()->size());
 
     // Disable Huffman coding by default. Most tests don't care about it.
     peer_.set_allow_huffman_compression(false);
   }
 
+  void SaveHeaders(StringPiece name, StringPiece value) {
+    StringPiece n(headers_storage_.Memdup(name.data(), name.size()),
+                  name.size());
+    StringPiece v(headers_storage_.Memdup(value.data(), value.size()),
+                  value.size());
+    headers_observed_.push_back(make_pair(n, v));
+  }
+
   void ExpectIndex(size_t index) {
     expected_.AppendPrefix(kIndexedOpcode);
     expected_.AppendUint32(index);
   }
   void ExpectIndexedLiteral(const HpackEntry* key_entry, StringPiece value) {
     expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
     expected_.AppendUint32(IndexOf(key_entry));
     expected_.AppendPrefix(kStringLiteralIdentityEncoded);
     expected_.AppendUint32(value.size());
     expected_.AppendBytes(value);
@@ skipping 34 matching lines @@
 
   HpackEncoder encoder_;
   test::HpackEncoderPeer peer_;
 
   const HpackEntry* static_;
   const HpackEntry* key_1_;
   const HpackEntry* key_2_;
   const HpackEntry* cookie_a_;
   const HpackEntry* cookie_c_;
 
+  UnsafeArena headers_storage_;
+  vector<pair<StringPiece, StringPiece>> headers_observed_;
+
   HpackOutputStream expected_;
 };
 
 TEST_F(HpackEncoderTest, SingleDynamicIndex) {
+  encoder_.SetHeaderListener([this](StringPiece name, StringPiece value) {
+    this->SaveHeaders(name, value);
+  });
+
   ExpectIndex(IndexOf(key_2_));
 
   SpdyHeaderBlock headers;
   headers[key_2_->name().as_string()] = key_2_->value().as_string();
   CompareWithExpectedEncoding(headers);
+  EXPECT_THAT(headers_observed_,
+              ElementsAre(Pair(key_2_->name(), key_2_->value())));
 }
 
 TEST_F(HpackEncoderTest, SingleStaticIndex) {
   ExpectIndex(IndexOf(static_));
 
   SpdyHeaderBlock headers;
   headers[static_->name().as_string()] = static_->value().as_string();
   CompareWithExpectedEncoding(headers);
 }
 
@@ skipping 84 matching lines @@
   expected_.AppendUint32(6);
   expected_.AppendBytes("@@@@@@");
 
   string expected_out, actual_out;
   expected_.TakeString(&expected_out);
   peer_.TakeString(&actual_out);
   EXPECT_EQ(expected_out, actual_out);
 }
 
 TEST_F(HpackEncoderTest, EncodingWithoutCompression) {
+  encoder_.SetHeaderListener([this](StringPiece name, StringPiece value) {
+    this->SaveHeaders(name, value);
+  });
+
   // Implementation should internally disable.
   peer_.set_allow_huffman_compression(true);
 
   ExpectNonIndexedLiteral(":path", "/index.html");
   ExpectNonIndexedLiteral("cookie", "foo=bar; baz=bing");
   ExpectNonIndexedLiteral("hello", "goodbye");
 
   SpdyHeaderBlock headers;
   headers[":path"] = "/index.html";
   headers["cookie"] = "foo=bar; baz=bing";
   headers["hello"] = "goodbye";
 
   string expected_out, actual_out;
   expected_.TakeString(&expected_out);
   encoder_.EncodeHeaderSetWithoutCompression(headers, &actual_out);
   EXPECT_EQ(expected_out, actual_out);
+
+  EXPECT_THAT(headers_observed_,
+              ElementsAre(Pair(":path", "/index.html"),
+                          Pair("cookie", "foo=bar; baz=bing"),
+                          Pair("hello", "goodbye")));
 }
 
 TEST_F(HpackEncoderTest, MultipleEncodingPasses) {
+  encoder_.SetHeaderListener([this](StringPiece name, StringPiece value) {
+    this->SaveHeaders(name, value);
+  });
+
   // Pass 1.
   {
     SpdyHeaderBlock headers;
     headers["key1"] = "value1";
     headers["cookie"] = "a=bb";
 
     ExpectIndex(IndexOf(key_1_));
     ExpectIndex(IndexOf(cookie_a_));
     CompareWithExpectedEncoding(headers);
   }
@@ skipping 32 matching lines @@
     ExpectIndex(65);
     // "cookie: a=bb"
     ExpectIndex(64);
     // This cookie evicts |key2| from the dynamic table.
     ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "b=cc");
     // "cookie: c=dd"
     ExpectIndex(64);
 
     CompareWithExpectedEncoding(headers);
   }
+
+  // clang-format off
+  EXPECT_THAT(headers_observed_,
+              ElementsAre(Pair("key1", "value1"),
+                          Pair("cookie", "a=bb"),
+                          Pair("key2", "value2"),
+                          Pair("cookie", "c=dd"),
+                          Pair("cookie", "e=ff"),
+                          Pair("key2", "value2"),
+                          Pair("cookie", "a=bb"),
+                          Pair("cookie", "b=cc"),
+                          Pair("cookie", "c=dd")));
+  // clang-format on
 }
 
 TEST_F(HpackEncoderTest, PseudoHeadersFirst) {
   SpdyHeaderBlock headers;
   // A pseudo-header that should not be indexed.
   headers[":path"] = "/spam/eggs.html";
   // A pseudo-header to be indexed.
   headers[":authority"] = "www.example.com";
   // A regular header which precedes ":" alphabetically, should still be encoded
   // after pseudo-headers.
@@ skipping 145 matching lines @@
   CompareWithExpectedEncoding(headers);
 
   HpackEntry* new_entry = &peer_.table_peer().dynamic_entries()->front();
   EXPECT_EQ(new_entry->name(), "key3");
   EXPECT_EQ(new_entry->value(), "value3");
 }
 
 }  // namespace
 
 }  // namespace net