This change removes SpdyFramer::set_enable_compression() in favor of a constructor parameter.

net/spdy/spdy_framer.cc

 // Copyright (c) 2012 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/spdy_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <cctype>
@@ skipping 135 matching lines @@
                                                    size_t len) {
   return true;
 }
 
 bool SpdyFramerVisitorInterface::OnRstStreamFrameData(
     const char* rst_stream_data,
     size_t len) {
   return true;
 }
 
-SpdyFramer::SpdyFramer(SpdyFramer::DecoderAdapterFactoryFn adapter_factory)
+SpdyFramer::SpdyFramer(SpdyFramer::DecoderAdapterFactoryFn adapter_factory,
+                       CompressionOption option)
     : current_frame_buffer_(kControlFrameBufferSize),
       expect_continuation_(0),
       visitor_(NULL),
       debug_visitor_(NULL),
       header_handler_(nullptr),
-      enable_compression_(true),
+      compression_option_(option),
       probable_http_response_(false),
       end_stream_when_done_(false) {
   // TODO(bnc): The way kMaxControlFrameSize is currently interpreted, it
   // includes the frame header, whereas kSpdyInitialFrameSizeLimit does not.
   // Therefore this assertion is unnecessarily strict.
   static_assert(kMaxControlFrameSize <= kSpdyInitialFrameSizeLimit,
                 "Our send limit should be at most our receive limit");
   Reset();
 
   if (adapter_factory != nullptr) {
     decoder_adapter_ = adapter_factory(this);
   }
 }
 
-SpdyFramer::SpdyFramer() : SpdyFramer(&DecoderAdapterFactory) {}
+SpdyFramer::SpdyFramer(CompressionOption option)
+    : SpdyFramer(&DecoderAdapterFactory, option) {}
 
 SpdyFramer::~SpdyFramer() {
 }
 
 void SpdyFramer::Reset() {
   if (decoder_adapter_ != nullptr) {
     decoder_adapter_->Reset();
   }
   state_ = SPDY_READY_FOR_FRAME;
   previous_state_ = SPDY_READY_FOR_FRAME;
@@ skipping 1587 matching lines @@
 
 SpdyFramer::SpdyHeaderFrameIterator::SpdyHeaderFrameIterator(
     SpdyFramer* framer,
     std::unique_ptr<SpdyHeadersIR> headers_ir)
     : headers_ir_(std::move(headers_ir)),
       framer_(framer),
       debug_total_size_(0),
       is_first_frame_(true),
       has_next_frame_(true) {
   encoder_ = framer_->GetHpackEncoder()->EncodeHeaderSet(
-      headers_ir_->header_block(), framer_->enable_compression_);
+      headers_ir_->header_block(), framer_->compression_enabled());
 }
 
 SpdyFramer::SpdyHeaderFrameIterator::~SpdyHeaderFrameIterator() {}
 
 SpdySerializedFrame SpdyFramer::SpdyHeaderFrameIterator::NextFrame() {
   if (!has_next_frame_) {
     SPDY_BUG << "SpdyFramer::SpdyHeaderFrameIterator::NextFrame called without "
              << "a next frame.";
     return SpdySerializedFrame();
   }
@@ skipping 201 matching lines @@
     size += headers.padding_payload_len();
   }
 
   int weight = 0;
   if (headers.has_priority()) {
     weight = ClampHttp2Weight(headers.weight());
     size += 5;
   }
 
   string hpack_encoding;
-  if (enable_compression_) {
+  if (compression_enabled()) {
     GetHpackEncoder()->EncodeHeaderSet(headers.header_block(), &hpack_encoding);
   } else {
     GetHpackEncoder()->EncodeHeaderSetWithoutCompression(headers.header_block(),
                                                          &hpack_encoding);
   }
   size += hpack_encoding.size();
   if (size > kMaxControlFrameSize) {
     size += GetNumberRequiredContinuationFrames(size) *
             GetContinuationMinimumSize();
     flags &= ~HEADERS_FLAG_END_HEADERS;
@@ skipping 56 matching lines @@
   // The size of this frame, including variable-length name-value block.
   size_t size = GetPushPromiseMinimumSize();
 
   if (push_promise.padded()) {
     flags |= PUSH_PROMISE_FLAG_PADDED;
     size += kPadLengthFieldSize;
     size += push_promise.padding_payload_len();
   }
 
   string hpack_encoding;
-  if (enable_compression_) {
+  if (compression_enabled()) {
     GetHpackEncoder()->EncodeHeaderSet(push_promise.header_block(),
                                        &hpack_encoding);
   } else {
     GetHpackEncoder()->EncodeHeaderSetWithoutCompression(
         push_promise.header_block(), &hpack_encoding);
   }
   size += hpack_encoding.size();
   if (size > kMaxControlFrameSize) {
     size += GetNumberRequiredContinuationFrames(size) *
             GetContinuationMinimumSize();
@@ skipping 343 matching lines @@
   builder->WriteUInt32(header_block.size());
 
   // Serialize each header.
   for (const auto& header : header_block) {
     builder->WriteStringPiece32(base::ToLowerASCII(header.first));
     builder->WriteStringPiece32(header.second);
   }
 }
 
 }  // namespace net