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

net/spdy/spdy_framer.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 301 matching lines @@
     SPDY_INVALID_DATA_FRAME_FLAGS,     // Data frame has invalid flags.
     SPDY_INVALID_CONTROL_FRAME_FLAGS,  // Control frame has invalid flags.
     SPDY_UNEXPECTED_FRAME,             // Frame received out of order.
     SPDY_INTERNAL_FRAMER_ERROR,        // SpdyFramer was used incorrectly.
     SPDY_INVALID_CONTROL_FRAME_SIZE,   // Control frame not sized to spec
     SPDY_OVERSIZED_PAYLOAD,            // Payload size was too large
 
     LAST_ERROR,  // Must be the last entry in the enum.
   };
 
+  enum CompressionOption {
+    ENABLE_COMPRESSION,
+    DISABLE_COMPRESSION,
+  };
+
   // Typedef for a function used to create SpdyFramerDecoderAdapter's.
   // Defined in support of evaluating an alternate HTTP/2 decoder.
   typedef std::unique_ptr<SpdyFramerDecoderAdapter> (*DecoderAdapterFactoryFn)(
       SpdyFramer* outer);
 
   // Constant for invalid (or unknown) stream IDs.
   static const SpdyStreamId kInvalidStream;
 
   // The maximum size of header data decompressed/delivered at once to the
   // header block parser. (Exposed here for unit test purposes.)
   static const size_t kHeaderDataChunkMaxSize;
 
   void SerializeHeaderBlockWithoutCompression(
       SpdyFrameBuilder* builder,
       const SpdyHeaderBlock& header_block) const;
 
   // Retrieve serialized length of SpdyHeaderBlock.
   static size_t GetSerializedLength(const SpdyHeaderBlock* headers);
 
-  SpdyFramer();
+  explicit SpdyFramer(CompressionOption option);
 
   // Used recursively from the above constructor in order to support
   // instantiating a SpdyFramerDecoderAdapter selected via flags or some other
   // means.
-  explicit SpdyFramer(DecoderAdapterFactoryFn adapter_factory);
+  SpdyFramer(DecoderAdapterFactoryFn adapter_factory, CompressionOption option);
 
   virtual ~SpdyFramer();
 
   // Set callbacks to be called from the framer.  A visitor must be set, or
   // else the framer will likely crash.  It is acceptable for the visitor
   // to do nothing.  If this is called multiple times, only the last visitor
   // will be used.
   void set_visitor(SpdyFramerVisitorInterface* visitor);
 
   // Set debug callbacks to be called from the framer. The debug visitor is
@@ skipping 111 matching lines @@
   // availability of an alternative service to the client.
   SpdySerializedFrame SerializeAltSvc(const SpdyAltSvcIR& altsvc);
 
   // Serializes a PRIORITY frame. The PRIORITY frame advises a change in
   // the relative priority of the given stream.
   SpdySerializedFrame SerializePriority(const SpdyPriorityIR& priority) const;
 
   // Serialize a frame of unknown type.
   SpdySerializedFrame SerializeFrame(const SpdyFrameIR& frame);
 
-  // For ease of testing and experimentation we can tweak compression on/off.
-  bool enable_compression() const { return enable_compression_; }
-  void set_enable_compression(bool value) {
-    enable_compression_ = value;
+  // Returns whether this SpdyFramer will compress header blocks using HPACK.
+  bool compression_enabled() const {
+    return compression_option_ == ENABLE_COMPRESSION;
   }
 
   void SetHpackIndexingPolicy(HpackEncoder::IndexingPolicy policy) {
     GetHpackEncoder()->SetIndexingPolicy(std::move(policy));
   }
 
   // Returns the (minimum) size of frames (sans variable-length portions).
   size_t GetDataFrameMinimumSize() const;
   size_t GetFrameHeaderSize() const;
   size_t GetRstStreamMinimumSize() const;
@@ skipping 267 matching lines @@
   std::unique_ptr<SpdyHeadersBlockParser> header_parser_;
   SpdyHeadersHandlerInterface* header_handler_;
 
   // Optional decoder to use instead of this instance.
   std::unique_ptr<SpdyFramerDecoderAdapter> decoder_adapter_;
 
   // The flags field of the frame currently being read.
   uint8_t current_frame_flags_;
 
   // Determines whether HPACK compression is used.
-  bool enable_compression_;
+  const CompressionOption compression_option_;
 
   // On the first read, we check to see if the data starts with HTTP.
   // If it does, we likely have an HTTP response.   This isn't guaranteed
   // though: we could have gotten a settings frame and then corrupt data that
   // just looks like HTTP, but deterministic checking requires a lot more state.
   bool probable_http_response_;
 
   // If a HEADERS frame is followed by a CONTINUATION frame, the FIN/END_STREAM
   // flag is still carried in the HEADERS frame. If it's set, flip this so that
   // we know to terminate the stream when the entire header block has been
   // processed.
   bool end_stream_when_done_;
 
   // If true, then ProcessInput returns after processing a full frame,
   // rather than reading all available input.
   bool process_single_input_frame_ = false;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_