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

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 64 matching lines @@
 }
 
 }  // 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),
+      enable_compression_(true),
       should_emit_table_size_(false) {}
 
 HpackEncoder::~HpackEncoder() {}
 
 void HpackEncoder::EncodeHeaderSet(const Representations& representations,
                                    string* output) {
   RepresentationIterator iter(representations);
   EncodeRepresentations(&iter, output);
 }
 
@@ skipping 17 matching lines @@
     }
   }
 
   {
     RepresentationIterator iter(pseudo_headers, regular_headers);
     EncodeRepresentations(&iter, output);
   }
   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);
+    if (enable_compression_) {
+      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);
+      }
     } else {
       EmitNonIndexedLiteral(header);
     }
   }
 
   output_stream_.TakeString(output);
 }
 
 void HpackEncoder::EmitIndex(const HpackEntry* entry) {
   output_stream_.AppendPrefix(kIndexedOpcode);
@@ skipping 19 matching lines @@
     output_stream_.AppendUint32(header_table_.IndexOf(name_entry));
   } else {
     output_stream_.AppendUint32(0);
     EmitString(representation.first);
   }
   EmitString(representation.second);
 }
 
 void HpackEncoder::EmitString(StringPiece str) {
   size_t encoded_size =
-      (!allow_huffman_compression_ ? str.size()
-                                   : huffman_table_.EncodedSize(str));
+      enable_compression_ ? huffman_table_.EncodedSize(str) : str.size();
   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);
   }
 }
@@ skipping 66 matching lines @@
 
 // static
 void HpackEncoder::GatherRepresentation(const Representation& header_field,
                                         Representations* out) {
   out->push_back(std::make_pair(header_field.first, header_field.second));
 }
 
 // Iteratively encodes a SpdyHeaderBlock.
 class HpackEncoder::Encoderator : public ProgressiveEncoder {
  public:
-  Encoderator(const SpdyHeaderBlock& header_set,
-              HpackEncoder* encoder,
-              bool use_compression);
+  Encoderator(const SpdyHeaderBlock& header_set, HpackEncoder* encoder);
 
   // Encoderator is neither copyable nor movable.
   Encoderator(const Encoderator&) = delete;
   Encoderator& operator=(const Encoderator&) = delete;
 
   // Returns true iff more remains to encode.
   bool HasNext() const override { return has_next_; }
 
   // Encodes up to max_encoded_bytes of the current header block into the
   // given output string.
   void Next(size_t max_encoded_bytes, string* output) override;
 
  private:
   HpackEncoder* encoder_;
   std::unique_ptr<RepresentationIterator> header_it_;
   Representations pseudo_headers_;
   Representations regular_headers_;
   bool has_next_;
-  bool use_compression_;
 };
 
 HpackEncoder::Encoderator::Encoderator(const SpdyHeaderBlock& header_set,
-                                       HpackEncoder* encoder,
-                                       bool use_compression)
-    : encoder_(encoder), has_next_(true), use_compression_(use_compression) {
+                                       HpackEncoder* encoder)
+    : encoder_(encoder), has_next_(true) {
   // Separate header set into pseudo-headers and regular headers.
+  const bool use_compression = encoder_->enable_compression_;
   bool found_cookie = false;
   for (const auto& header : header_set) {
     if (!found_cookie && header.first == "cookie") {
       // Note that there can only be one "cookie" header, because header_set
       // is a map.
       found_cookie = true;
-      use_compression_ ? CookieToCrumbs(header, &regular_headers_)
-                       : GatherRepresentation(header, &regular_headers_);
+      CookieToCrumbs(header, &regular_headers_);
     } else if (!header.first.empty() &&
                header.first[0] == kPseudoHeaderPrefix) {
-      use_compression_ ? DecomposeRepresentation(header, &pseudo_headers_)
-                       : GatherRepresentation(header, &pseudo_headers_);
+      use_compression ? DecomposeRepresentation(header, &pseudo_headers_)
+                      : GatherRepresentation(header, &pseudo_headers_);
     } else {
-      use_compression_ ? DecomposeRepresentation(header, &regular_headers_)
-                       : GatherRepresentation(header, &regular_headers_);
+      use_compression ? DecomposeRepresentation(header, &regular_headers_)
+                      : GatherRepresentation(header, &regular_headers_);
     }
   }
   header_it_ = base::MakeUnique<RepresentationIterator>(pseudo_headers_,
                                                         regular_headers_);
 
   encoder_->MaybeEmitTableSize();
 }
 
 void HpackEncoder::Encoderator::Next(size_t max_encoded_bytes, string* output) {
   SPDY_BUG_IF(!has_next_)
       << "Encoderator::Next called with nothing left to encode.";
+  const bool use_compression = encoder_->enable_compression_;
 
   // Encode up to max_encoded_bytes of headers.
   while (header_it_->HasNext() &&
          encoder_->output_stream_.size() <= max_encoded_bytes) {
     const Representation header = header_it_->Next();
     encoder_->listener_(header.first, header.second);
-    if (use_compression_) {
+    if (use_compression) {
       const HpackEntry* entry = encoder_->header_table_.GetByNameAndValue(
           header.first, header.second);
       if (entry != nullptr) {
         encoder_->EmitIndex(entry);
       } else if (encoder_->should_index_(header.first, header.second)) {
         encoder_->EmitIndexedLiteral(header);
       } else {
         encoder_->EmitNonIndexedLiteral(header);
       }
     } else {
-      encoder_->allow_huffman_compression_ = false;
       encoder_->EmitNonIndexedLiteral(header);
-      encoder_->allow_huffman_compression_ = true;
     }
   }
 
   has_next_ = encoder_->output_stream_.size() > max_encoded_bytes;
   encoder_->output_stream_.BoundedTakeString(max_encoded_bytes, output);
 }
 
 std::unique_ptr<HpackEncoder::ProgressiveEncoder> HpackEncoder::EncodeHeaderSet(
-    const SpdyHeaderBlock& header_set,
-    bool use_compression) {
-  return base::MakeUnique<Encoderator>(header_set, this, use_compression);
+    const SpdyHeaderBlock& header_set) {
+  return base::MakeUnique<Encoderator>(header_set, this);
 }
 
 }  // namespace net