This change removes HpackEncoder::EncodeHeaderSetWithoutCompression() and the corresponding progres…

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 "base/rand_util.h"
 #include "net/base/arena.h"
+#include "net/spdy/hpack/hpack_huffman_table.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;
@@ skipping 12 matching lines @@
   HpackHeaderTable* table_;
 };
 
 class HpackEncoderPeer {
  public:
   typedef HpackEncoder::Representation Representation;
   typedef HpackEncoder::Representations Representations;
 
   explicit HpackEncoderPeer(HpackEncoder* encoder) : encoder_(encoder) {}
 
+  bool compression_enabled() const { return encoder_->enable_compression_; }
   HpackHeaderTable* table() { return &encoder_->header_table_; }
   HpackHeaderTablePeer table_peer() { return HpackHeaderTablePeer(table()); }
-  void set_allow_huffman_compression(bool allow) {
-    encoder_->allow_huffman_compression_ = allow;
+  const HpackHuffmanTable& huffman_table() const {
+    return encoder_->huffman_table_;
   }
   void EmitString(StringPiece str) { encoder_->EmitString(str); }
   void TakeString(string* out) { encoder_->output_stream_.TakeString(out); }
   static void CookieToCrumbs(StringPiece cookie,
                              std::vector<StringPiece>* out) {
     Representations tmp;
     HpackEncoder::CookieToCrumbs(std::make_pair("", cookie), &tmp);
 
     out->clear();
     for (size_t i = 0; i != tmp.size(); ++i) {
@@ skipping 10 matching lines @@
     for (size_t i = 0; i != tmp.size(); ++i) {
       out->push_back(tmp[i].second);
     }
   }
 
   // TODO(dahollings): Remove or clean up these methods when deprecating
   // non-incremental encoding path.
   static bool EncodeHeaderSet(HpackEncoder* encoder,
                               const SpdyHeaderBlock& header_set,
                               string* output,
-                              bool use_compression,
                               bool use_incremental) {
     if (use_incremental) {
-      return EncodeIncremental(encoder, header_set, output, use_compression);
+      return EncodeIncremental(encoder, header_set, output);
     } else {
-      return use_compression ? encoder->EncodeHeaderSet(header_set, output)
-                             : encoder->EncodeHeaderSetWithoutCompression(
-                                   header_set, output);
+      return encoder->EncodeHeaderSet(header_set, output);
     }
   }
 
   static bool EncodeIncremental(HpackEncoder* encoder,
                                 const SpdyHeaderBlock& header_set,
-                                string* output,
-                                bool use_compression) {
+                                string* output) {
     std::unique_ptr<HpackEncoder::ProgressiveEncoder> encoderator =
-        encoder->EncodeHeaderSet(header_set, use_compression);
+        encoder->EncodeHeaderSet(header_set);
     string output_buffer;
     encoderator->Next(base::RandInt(0, 15), &output_buffer);
     while (encoderator->HasNext()) {
       string second_buffer;
       encoderator->Next(base::RandInt(0, 15), &second_buffer);
       output_buffer.append(second_buffer);
     }
     *output = std::move(output_buffer);
     return true;
   }
@@ skipping 25 matching lines @@
 
     // 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);
+    ExpectString(&expected_, value);
   }
   void ExpectIndexedLiteral(StringPiece name, StringPiece value) {
     expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
     expected_.AppendUint32(0);
-    expected_.AppendPrefix(kStringLiteralIdentityEncoded);
-    expected_.AppendUint32(name.size());
-    expected_.AppendBytes(name);
-    expected_.AppendPrefix(kStringLiteralIdentityEncoded);
-    expected_.AppendUint32(value.size());
-    expected_.AppendBytes(value);
+    ExpectString(&expected_, name);
+    ExpectString(&expected_, value);
   }
   void ExpectNonIndexedLiteral(StringPiece name, StringPiece value) {
     expected_.AppendPrefix(kLiteralNoIndexOpcode);
     expected_.AppendUint32(0);
-    expected_.AppendPrefix(kStringLiteralIdentityEncoded);
-    expected_.AppendUint32(name.size());
-    expected_.AppendBytes(name);
-    expected_.AppendPrefix(kStringLiteralIdentityEncoded);
-    expected_.AppendUint32(value.size());
-    expected_.AppendBytes(value);
+    ExpectString(&expected_, name);
+    ExpectString(&expected_, value);
+  }
+  void ExpectString(HpackOutputStream* stream, StringPiece str) {
+    const HpackHuffmanTable& huffman_table = peer_.huffman_table();
+    size_t encoded_size = peer_.compression_enabled()
+                              ? huffman_table.EncodedSize(str)
+                              : str.size();
+    if (encoded_size < str.size()) {
+      expected_.AppendPrefix(kStringLiteralHuffmanEncoded);
+      expected_.AppendUint32(encoded_size);
+      huffman_table.EncodeString(str, stream);
+    } else {
+      expected_.AppendPrefix(kStringLiteralIdentityEncoded);
+      expected_.AppendUint32(str.size());
+      expected_.AppendBytes(str);
+    }
   }
   void ExpectHeaderTableSizeUpdate(uint32_t size) {
     expected_.AppendPrefix(kHeaderTableSizeUpdateOpcode);
     expected_.AppendUint32(size);
   }
   void CompareWithExpectedEncoding(const SpdyHeaderBlock& header_set) {
     string expected_out, actual_out;
     expected_.TakeString(&expected_out);
     EXPECT_TRUE(test::HpackEncoderPeer::EncodeHeaderSet(
-        &encoder_, header_set, &actual_out, true, use_incremental_));
-    EXPECT_EQ(expected_out, actual_out);
-  }
-  void CompareWithExpectedEncodingWithoutCompression(
-      const SpdyHeaderBlock& header_set) {
-    string expected_out, actual_out;
-    expected_.TakeString(&expected_out);
-    EXPECT_TRUE(test::HpackEncoderPeer::EncodeHeaderSet(
-        &encoder_, header_set, &actual_out, false, use_incremental_));
+        &encoder_, header_set, &actual_out, use_incremental_));
     EXPECT_EQ(expected_out, actual_out);
   }
   size_t IndexOf(const HpackEntry* entry) {
     return peer_.table()->IndexOf(entry);
   }
 
   HpackEncoder encoder_;
   test::HpackEncoderPeer peer_;
 
   const HpackEntry* static_;
@@ skipping 99 matching lines @@
   ExpectIndex(IndexOf(cookie_a_));
   ExpectIndex(IndexOf(cookie_c_));
   ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "e=ff");
 
   SpdyHeaderBlock headers;
   headers["cookie"] = "a=bb; c=dd; e=ff";
   CompareWithExpectedEncoding(headers);
 }
 
 TEST_P(HpackEncoderTest, StringsDynamicallySelectHuffmanCoding) {
-  peer_.set_allow_huffman_compression(true);
-
   // Compactable string. Uses Huffman coding.
   peer_.EmitString("feedbeef");
   expected_.AppendPrefix(kStringLiteralHuffmanEncoded);
   expected_.AppendUint32(6);
   expected_.AppendBytes("\x94\xA5\x92\x32\x96_");
 
   // Non-compactable. Uses identity coding.
   peer_.EmitString("@@@@@@");
   expected_.AppendPrefix(kStringLiteralIdentityEncoded);
   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_P(HpackEncoderTest, EncodingWithoutCompression) {
   encoder_.SetHeaderListener([this](StringPiece name, StringPiece value) {
     this->SaveHeaders(name, value);
   });
-
-  // Implementation should internally disable.
-  peer_.set_allow_huffman_compression(true);
+  encoder_.DisableCompression();
 
   ExpectNonIndexedLiteral(":path", "/index.html");
-  ExpectNonIndexedLiteral("cookie", "foo=bar; baz=bing");
+  ExpectNonIndexedLiteral("cookie", "foo=bar");
+  ExpectNonIndexedLiteral("cookie", "baz=bing");
   ExpectNonIndexedLiteral("hello", "goodbye");
 
   SpdyHeaderBlock headers;
   headers[":path"] = "/index.html";
   headers["cookie"] = "foo=bar; baz=bing";
   headers["hello"] = "goodbye";
 
-  CompareWithExpectedEncodingWithoutCompression(headers);
+  CompareWithExpectedEncoding(headers);
 
-  EXPECT_THAT(headers_observed_,
-              ElementsAre(Pair(":path", "/index.html"),
-                          Pair("cookie", "foo=bar; baz=bing"),
-                          Pair("hello", "goodbye")));
+  EXPECT_THAT(
+      headers_observed_,
+      ElementsAre(Pair(":path", "/index.html"), Pair("cookie", "foo=bar"),
+                  Pair("cookie", "baz=bing"), Pair("hello", "goodbye")));
 }
 
 TEST_P(HpackEncoderTest, MultipleEncodingPasses) {
   encoder_.SetHeaderListener([this](StringPiece name, StringPiece value) {
     this->SaveHeaders(name, value);
   });
 
   // Pass 1.
   {
     SpdyHeaderBlock headers;
@@ skipping 217 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