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

net/spdy/spdy_framer_test.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 <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 51 matching lines @@
   //
   // Returns a new decompressed SpdySerializedFrame.
   template <class SpdyFrameType>
   static SpdySerializedFrame DecompressFrame(SpdyFramer* framer,
                                              const SpdyFrameType& frame) {
     DecompressionVisitor visitor;
     framer->set_visitor(&visitor);
     CHECK_EQ(frame.size(), framer->ProcessInput(frame.data(), frame.size()));
     CHECK_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer->state());
     framer->set_visitor(nullptr);
-    SpdyFramer serializer;
-    serializer.set_enable_compression(false);
+    SpdyFramer serializer(SpdyFramer::DISABLE_COMPRESSION);
     return serializer.SerializeFrame(visitor.GetFrame());
   }
 
   class DecompressionVisitor : public SpdyFramerVisitorInterface {
    public:
     DecompressionVisitor() : finished_(false) {}
 
     const SpdyFrameIR& GetFrame() const {
       CHECK(finished_);
       return *frame_;
@@ skipping 181 matching lines @@
   }
 };
 
 class TestSpdyVisitor : public SpdyFramerVisitorInterface,
                         public SpdyFramerDebugVisitorInterface {
  public:
   // This is larger than our max frame size because header blocks that
   // are too long can spill over into CONTINUATION frames.
   static const size_t kDefaultHeaderBufferSize = 16 * 1024 * 1024;
 
-  TestSpdyVisitor()
-      : use_compression_(false),
+  explicit TestSpdyVisitor(SpdyFramer::CompressionOption option)
+      : framer_(option),
         error_count_(0),
         headers_frame_count_(0),
         push_promise_frame_count_(0),
         goaway_count_(0),
         setting_count_(0),
         settings_ack_sent_(0),
         settings_ack_received_(0),
         continuation_count_(0),
         altsvc_count_(0),
         priority_count_(0),
@@ skipping 200 matching lines @@
   void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                 SpdyFrameType type,
                                 size_t frame_len) override {
     VLOG(1) << "OnReceiveCompressedFrame(" << stream_id << ", " << type << ", "
             << frame_len << ")";
     last_frame_len_ = frame_len;
   }
 
   // Convenience function which runs a framer simulation with particular input.
   void SimulateInFramer(const unsigned char* input, size_t size) {
-    framer_.set_enable_compression(use_compression_);
     framer_.set_visitor(this);
     size_t input_remaining = size;
     const char* input_ptr = reinterpret_cast<const char*>(input);
     while (input_remaining > 0 &&
            framer_.error_code() == SpdyFramer::SPDY_NO_ERROR) {
       // To make the tests more interesting, we feed random (and small) chunks
       // into the framer.  This simulates getting strange-sized reads from
       // the socket.
       const size_t kMaxReadSize = 32;
       size_t bytes_read =
@@ skipping 35 matching lines @@
   // excluding the size of the header.
   static size_t received_control_frame_max_size() {
     return kSpdyInitialFrameSizeLimit;
   }
 
   static size_t header_data_chunk_max_size() {
     return SpdyFramer::kHeaderDataChunkMaxSize;
   }
 
   SpdyFramer framer_;
-  bool use_compression_;
 
   // Counters from the visitor callbacks.
   int error_count_;
   int headers_frame_count_;
   int push_promise_frame_count_;
   int goaway_count_;
   int setting_count_;
   int settings_ack_sent_;
   int settings_ack_received_;
   int continuation_count_;
@@ skipping 106 matching lines @@
 INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
                         SpdyFramerTest,
                         ::testing::Combine(::testing::Values(DECODER_SELF,
                                                              DECODER_NESTED,
                                                              DECODER_HTTP2),
                                            ::testing::Values(HPACK_DECODER_1,
                                                              HPACK_DECODER_2)));
 
 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
 TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
-  SpdyFramer framer;
-  framer.set_enable_compression(false);
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                            frame.size());
 
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(headers.header_block(), visitor.headers_);
 }
 
 // Test that if there's not a full frame, we fail to parse it.
 TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
-  SpdyFramer framer;
-  framer.set_enable_compression(false);
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                            frame.size() - 2);
 
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0u, visitor.headers_.size());
 }
 
 // Test that we treat incoming upper-case or mixed-case header values as
 // malformed.
 TEST_P(SpdyFramerTest, RejectUpperCaseHeaderBlockValue) {
-  SpdyFramer framer;
-  framer.set_enable_compression(false);
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
 
   SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, HEADERS, 0, 1);
   frame.WriteUInt32(1);
   frame.WriteStringPiece32("Name1");
   frame.WriteStringPiece32("value1");
   frame.RewriteLength(framer);
 
   SpdyFrameBuilder frame2(1024);
   frame2.BeginNewFrame(framer, HEADERS, 0, 1);
@@ skipping 13 matching lines @@
   SpdyHeaderBlock new_headers;
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(
       serialized_headers.data(), serialized_headers.size(), &new_headers));
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(
       serialized_headers2.data(), serialized_headers2.size(), &new_headers));
 }
 
 // Test that we can encode and decode stream dependency values in a header
 // frame.
 TEST_P(SpdyFramerTest, HeaderStreamDependencyValues) {
-  SpdyFramer framer;
-  framer.set_enable_compression(false);
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
 
   const SpdyStreamId parent_stream_id_test_array[] = {0, 3};
   for (SpdyStreamId parent_stream_id : parent_stream_id_test_array) {
     const bool exclusive_test_array[] = {true, false};
     for (bool exclusive : exclusive_test_array) {
       SpdyHeadersIR headers(1);
       headers.set_has_priority(true);
       headers.set_parent_stream_id(parent_stream_id);
       headers.set_exclusive(exclusive);
       SpdySerializedFrame frame(
           SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
-      TestSpdyVisitor visitor;
-      visitor.use_compression_ = false;
+      TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
       visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                                frame.size());
 
       EXPECT_TRUE(visitor.header_has_priority_);
       EXPECT_EQ(parent_stream_id, visitor.header_parent_stream_id_);
       EXPECT_EQ(exclusive, visitor.header_exclusive_);
     }
   }
 }
 
 // Test that if we receive a frame with payload length field at the
 // advertised max size, we do not set an error in ProcessInput.
 TEST_P(SpdyFramerTest, AcceptMaxFrameSizeSetting) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   // DATA frame with maximum allowed payload length.
   unsigned char kH2FrameData[] = {
       0x00, 0x40, 0x00,        // Length: 2^14
       0x00,                    //   Type: HEADERS
       0x00,                    //  Flags: None
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  // Junk payload
   };
 
   SpdySerializedFrame frame(reinterpret_cast<char*>(kH2FrameData),
                             sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnDataFrameHeader(1, 1 << 14, false));
   EXPECT_CALL(visitor, OnStreamFrameData(1, _, 4));
   framer.ProcessInput(frame.data(), frame.size());
   EXPECT_FALSE(framer.HasError());
 }
 
 // Test that if we receive a frame with payload length larger than the
 // advertised max size, we set an error of SPDY_INVALID_CONTROL_FRAME_SIZE.
 TEST_P(SpdyFramerTest, ExceedMaxFrameSizeSetting) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   // DATA frame with too large payload length.
   unsigned char kH2FrameData[] = {
       0x00, 0x40, 0x01,        // Length: 2^14 + 1
       0x00,                    //   Type: HEADERS
       0x00,                    //  Flags: None
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  // Junk payload
   };
 
   SpdySerializedFrame frame(reinterpret_cast<char*>(kH2FrameData),
                             sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   framer.ProcessInput(frame.data(), frame.size());
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_OVERSIZED_PAYLOAD, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a DATA frame with padding length larger than the
 // payload length, we set an error of SPDY_INVALID_PADDING
 TEST_P(SpdyFramerTest, OversizedDataPaddingError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   // DATA frame with invalid padding length.
   // |kH2FrameData| has to be |unsigned char|, because Chromium on Windows uses
   // MSVC, where |char| is signed by default, which would not compile because of
   // the element exceeding 127.
   unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x00,                    //   Type: DATA
       0x09,                    //  Flags: END_STREAM|PADDED
@@ skipping 14 matching lines @@
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_PADDING, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a DATA frame with padding length not larger than the
 // payload length, we do not set an error of SPDY_INVALID_PADDING
 TEST_P(SpdyFramerTest, CorrectlySizedDataPaddingNoError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   // DATA frame with valid Padding length
   char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x00,                    //   Type: DATA
       0x08,                    //  Flags: PADDED
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x04,                    // PadLen: 4 trailing bytes
       0x00, 0x00, 0x00, 0x00,  // Padding
@@ skipping 14 matching lines @@
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_FALSE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a HEADERS frame with padding length larger than the
 // payload length, we set an error of SPDY_INVALID_PADDING
 TEST_P(SpdyFramerTest, OversizedHeadersPaddingError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   // HEADERS frame with invalid padding length.
   // |kH2FrameData| has to be |unsigned char|, because Chromium on Windows uses
   // MSVC, where |char| is signed by default, which would not compile because of
   // the element exceeding 127.
   unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x01,                    //   Type: HEADERS
       0x08,                    //  Flags: PADDED
@@ skipping 11 matching lines @@
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_PADDING, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a HEADERS frame with padding length not larger
 // than the payload length, we do not set an error of SPDY_INVALID_PADDING
 TEST_P(SpdyFramerTest, CorrectlySizedHeadersPaddingNoError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   // HEADERS frame with invalid Padding length
   char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x01,                    //   Type: HEADERS
       0x08,                    //  Flags: PADDED
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x04,                    // PadLen: 4 trailing bytes
       0x00, 0x00, 0x00, 0x00,  // Padding
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnHeaders(1, false, 0, 0, false, false, false));
   EXPECT_CALL(visitor, OnHeaderFrameStart(1)).Times(1);
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_FALSE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a DATA with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, DataWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   const char bytes[] = "hello";
   SpdyDataIR data_ir(0, bytes);
   SpdySerializedFrame frame(framer.SerializeData(data_ir));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a HEADERS with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, HeadersWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyHeadersIR headers(0);
   headers.SetHeader("alpha", "beta");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PRIORITY with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, PriorityWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyPriorityIR priority_ir(0, 1, 16, true);
   SpdySerializedFrame frame(framer.SerializeFrame(priority_ir));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a RST_STREAM with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, RstStreamWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyRstStreamIR rst_stream_ir(0, RST_STREAM_PROTOCOL_ERROR);
   SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream_ir));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a SETTINGS with stream ID other than zero,
 // we signal an error (but don't crash).
 TEST_P(SpdyFramerTest, SettingsWithStreamIdNotZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   // Settings frame with invalid StreamID of 0x01
   char kH2FrameData[] = {
       0x00, 0x00, 0x06,        // Length: 6
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x04,              //  Param: INITIAL_WINDOW_SIZE
       0x0a, 0x0b, 0x0c, 0x0d,  //  Value: 168496141
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a GOAWAY with stream ID other than zero,
 // we signal an error (but don't crash).
 TEST_P(SpdyFramerTest, GoawayWithStreamIdNotZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   // GOAWAY frame with invalid StreamID of 0x01
   char kH2FrameData[] = {
       0x00, 0x00, 0x0a,        // Length: 10
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  //   Last: 0
       0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
       0x47, 0x41,              // Description
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a CONTINUATION with stream ID zero, we signal an
 // SPDY_INVALID_STREAM_ID.
 TEST_P(SpdyFramerTest, ContinuationWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyContinuationIR continuation(0);
   auto some_nonsense_encoding =
       base::MakeUnique<string>("some nonsense encoding");
   continuation.take_encoding(std::move(some_nonsense_encoding));
   continuation.set_end_headers(true);
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PUSH_PROMISE with stream ID zero, we signal an
 // SPDY_INVALID_STREAM_ID.
 TEST_P(SpdyFramerTest, PushPromiseWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(0, 4);
   push_promise.SetHeader("alpha", "beta");
   SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PUSH_PROMISE with promised stream ID zero, we
 // signal SPDY_INVALID_STREAM_ID.
 TEST_P(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(3, 0);
   push_promise.SetHeader("alpha", "beta");
   SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
 
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   framer.ProcessInput(frame.data(), frame.size());
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, DuplicateHeader) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, HEADERS, 0, 3);
 
   frame.WriteUInt32(2);  // Number of headers.
   frame.WriteStringPiece32("name");
   frame.WriteStringPiece32("value1");
   frame.WriteStringPiece32("name");
   frame.WriteStringPiece32("value2");
   // write the length
   frame.RewriteLength(framer);
 
   SpdyHeaderBlock new_headers;
-  framer.set_enable_compression(false);
   SpdySerializedFrame control_frame(frame.take());
   StringPiece serialized_headers = GetSerializedHeaders(control_frame, framer);
   // This should fail because duplicate headers are verboten by the spec.
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(
       serialized_headers.data(), serialized_headers.size(), &new_headers));
 }
 
 TEST_P(SpdyFramerTest, MultiValueHeader) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, HEADERS,
                       HEADERS_FLAG_PRIORITY | HEADERS_FLAG_END_HEADERS, 3);
   frame.WriteUInt32(0);   // Priority exclusivity and dependent stream.
   frame.WriteUInt8(255);  // Priority weight.
 
   string value("value1\0value2", 13);
   // TODO(jgraettinger): If this pattern appears again, move to test class.
   SpdyHeaderBlock header_set;
   header_set["name"] = value;
   string buffer;
   HpackEncoder encoder(ObtainHpackHuffmanTable());
   encoder.EncodeHeaderSetWithoutCompression(header_set, &buffer);
   frame.WriteBytes(&buffer[0], buffer.size());
   // write the length
   frame.RewriteLength(framer);
 
-  framer.set_enable_compression(false);
   SpdySerializedFrame control_frame(frame.take());
 
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
 
   EXPECT_THAT(visitor.headers_,
               testing::ElementsAre(testing::Pair("name", StringPiece(value))));
 }
 
 TEST_P(SpdyFramerTest, CompressEmptyHeaders) {
   // See crbug.com/172383
   SpdyHeadersIR headers(1);
   headers.SetHeader("server", "SpdyServer 1.0");
   headers.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
   headers.SetHeader("status", "200");
   headers.SetHeader("version", "HTTP/1.1");
   headers.SetHeader("content-type", "text/html");
   headers.SetHeader("content-length", "12");
   headers.SetHeader("x-empty-header", "");
 
-  SpdyFramer framer;
-  framer.set_enable_compression(true);
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdySerializedFrame frame1(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
 }
 
 TEST_P(SpdyFramerTest, Basic) {
   // Send HEADERS frames with PRIORITY and END_HEADERS set.
   // frame-format off
   const unsigned char kH2Input[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x01,                    //   Type: HEADERS
@@ skipping 48 matching lines @@
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
 
       0x00, 0x00, 0x04,        // Length: 4
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x00, 0x08,  //  Error: CANCEL
   };
   // frame-format on
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kH2Input, sizeof(kH2Input));
 
   EXPECT_EQ(24, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.fin_frame_count_);
 
   EXPECT_EQ(3, visitor.headers_frame_count_);
   EXPECT_TRUE(visitor.fin_opaque_data_.empty());
 
   EXPECT_EQ(0, visitor.fin_flag_count_);
@@ skipping 29 matching lines @@
       0xde, 0xad, 0xbe, 0xef,  //
 
       0x00, 0x00, 0x04,        // Length: 4
       0x00,                    //   Type: DATA
       0x01,                    //  Flags: END_STREAM
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0xde, 0xad, 0xbe, 0xef,  // Payload
   };
   // frame-format on
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kH2Input, sizeof(kH2Input));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.headers_frame_count_);
   EXPECT_EQ(16, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
   EXPECT_EQ(2, visitor.data_frame_count_);
 }
@@ skipping 10 matching lines @@
       0x82,                    // Weight: 131
 
       0x00, 0x00, 0x01,        // Length: 1
       0x01,                    //   Type: HEADERS
       0x05,                    //  Flags: END_STREAM|END_HEADERS
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x8c,                    // :status: 200
   };
   // frame-format on
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kH2Input, sizeof(kH2Input));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(1, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 // Verify we can decompress the stream even if handed over to the
 // framer 1 byte at a time.
 TEST_P(SpdyFramerTest, UnclosedStreamDataCompressorsOneByteAtATime) {
-  SpdyFramer framer;
-
-  framer.set_enable_compression(true);
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   const char kHeader1[] = "header1";
   const char kHeader2[] = "header2";
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
 
   SpdyHeadersIR headers(1);
   headers.SetHeader(kHeader1, kValue1);
   headers.SetHeader(kHeader2, kValue2);
   SpdySerializedFrame headers_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
   const char bytes[] = "this is a test test test test test!";
   SpdyDataIR data_ir(1, StringPiece(bytes, arraysize(bytes)));
   data_ir.set_fin(true);
   SpdySerializedFrame send_frame(framer.SerializeData(data_ir));
 
   // Run the inputs through the framer.
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = true;
+  TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION);
   const unsigned char* data;
   data = reinterpret_cast<const unsigned char*>(headers_frame.data());
   for (size_t idx = 0; idx < headers_frame.size(); ++idx) {
     visitor.SimulateInFramer(data + idx, 1);
     ASSERT_EQ(0, visitor.error_count_);
   }
   data = reinterpret_cast<const unsigned char*>(send_frame.data());
   for (size_t idx = 0; idx < send_frame.size(); ++idx) {
     visitor.SimulateInFramer(data + idx, 1);
     ASSERT_EQ(0, visitor.error_count_);
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(arraysize(bytes), static_cast<unsigned>(visitor.data_bytes_));
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
   EXPECT_EQ(1, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, WindowUpdateFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdySerializedFrame frame(
       framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x12345678)));
 
   const char kDescription[] = "WINDOW_UPDATE frame, stream 1, delta 0x12345678";
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x08,                    //   Type: WINDOW_UPDATE
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x12, 0x34, 0x56, 0x78,  // Increment: 305419896
   };
 
   CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
 }
 
 TEST_P(SpdyFramerTest, CreateDataFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   {
     const char kDescription[] = "'hello' data frame, no FIN";
     // frame-format off
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x05,        // Length: 5
         0x00,                    //   Type: DATA
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         'h',  'e',  'l',  'l',   // Payload
@@ skipping 181 matching lines @@
         0x6f,                    //
     };
     SpdyDataIR data_ir(0x7fffffff, "hello");
     data_ir.set_fin(true);
     SpdySerializedFrame frame(framer.SerializeData(data_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateRstStream) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   {
     const char kDescription[] = "RST_STREAM frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04,        // Length: 4
         0x03,                    //   Type: RST_STREAM
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         0x00, 0x00, 0x00, 0x01,  //  Error: PROTOCOL_ERROR
     };
@@ skipping 25 matching lines @@
         0x7f, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff
         0x00, 0x00, 0x00, 0x02,  //  Error: INTERNAL_ERROR
     };
     SpdyRstStreamIR rst_stream(0x7FFFFFFF, RST_STREAM_INTERNAL_ERROR);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSettings) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   {
     const char kDescription[] = "Network byte order SETTINGS frame";
 
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x06,        // Length: 6
         0x04,                    //   Type: SETTINGS
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x00, 0x04,              //  Param: INITIAL_WINDOW_SIZE
@@ skipping 63 matching lines @@
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
     };
     SpdySettingsIR settings_ir;
     SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreatePingFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   {
     const char kDescription[] = "PING frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x08,        // Length: 8
         0x06,                    //   Type: PING
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x12, 0x34, 0x56, 0x78,  // Opaque
         0x9a, 0xbc, 0xde, 0xff,  //     Data
@@ skipping 16 matching lines @@
 
     // Tests SpdyPingIR when the ping is an ack.
     ping_ir.set_is_ack(true);
     frame = framer.SerializePing(ping_ir);
     CompareFrame(kDescription, frame, kH2FrameDataWithAck,
                  arraysize(kH2FrameDataWithAck));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateGoAway) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   {
     const char kDescription[] = "GOAWAY frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x0a,        // Length: 10
         0x07,                    //   Type: GOAWAY
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x00, 0x00, 0x00, 0x00,  //   Last: 0
         0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
@@ skipping 15 matching lines @@
         0x00, 0x00, 0x00, 0x02,  //  Error: INTERNAL_ERROR
         0x47, 0x41,              // Description
     };
     SpdyGoAwayIR goaway_ir(0x7FFFFFFF, GOAWAY_INTERNAL_ERROR, "GA");
     SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateHeadersUncompressed) {
-  SpdyFramer framer;
-  framer.set_enable_compression(false);
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
     // frame-format off
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x12,        // Length: 18
         0x01,                    //   Type: HEADERS
         0x04,                    //  Flags: END_HEADERS
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
 
@@ skipping 230 matching lines @@
     SpdySerializedFrame frame(
         SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateHeadersCompressed) {
-  SpdyFramer framer;
-  framer.set_enable_compression(true);
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   {
     SpdyHeadersIR headers_ir(1);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "bar");
     SpdySerializedFrame frame(
         SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
     // Deflate compression doesn't apply to HPACK.
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateWindowUpdate) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04,        // Length: 4
         0x08,                    //   Type: WINDOW_UPDATE
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         0x00, 0x00, 0x00, 0x01,  // Increment: 1
     };
@@ skipping 25 matching lines @@
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         0x7f, 0xff, 0xff, 0xff,  // Increment: 0x7fffffff
     };
     SpdySerializedFrame frame(
         framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x7FFFFFFF)));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, SerializeBlocked) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   const char kDescription[] = "BLOCKED frame";
   const unsigned char kType =
       static_cast<unsigned char>(SpdyConstants::SerializeFrameType(BLOCKED));
   const unsigned char kFrameData[] = {
       0x00,  0x00, 0x00,        // Length: 0
       kType,                    //   Type: BLOCKED
       0x00,                     //  Flags: none
       0x00,  0x00, 0x00, 0x00,  // Stream: 0
   };
   SpdyBlockedIR blocked_ir(0);
   SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, CreateBlocked) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   const char kDescription[] = "BLOCKED frame";
   const SpdyStreamId kStreamId = 3;
 
   SpdySerializedFrame frame_serialized(
       framer.SerializeBlocked(SpdyBlockedIR(kStreamId)));
   SpdyBlockedIR blocked_ir(kStreamId);
   SpdySerializedFrame frame_created(framer.SerializeFrame(blocked_ir));
 
   CompareFrames(kDescription, frame_serialized, frame_created);
 }
 
 TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) {
   {
     // Test framing PUSH_PROMISE without padding.
-    SpdyFramer framer;
-    framer.set_enable_compression(false);
+    SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
     const char kDescription[] = "PUSH_PROMISE frame without padding";
 
     // frame-format off
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0x16,        // Length: 22
         0x05,                    //   Type: PUSH_PROMISE
         0x04,                    //  Flags: END_HEADERS
         0x00, 0x00, 0x00, 0x29,  // Stream: 41
         0x00, 0x00, 0x00, 0x3a,  // Promise: 58
 
@@ skipping 13 matching lines @@
 
     SpdyPushPromiseIR push_promise(41, 58);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   }
 
   {
     // Test framing PUSH_PROMISE with one byte of padding.
-    SpdyFramer framer;
-    framer.set_enable_compression(false);
+    SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
     const char kDescription[] = "PUSH_PROMISE frame with one byte of padding";
 
     // frame-format off
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0x17,        // Length: 23
         0x05,                    //   Type: PUSH_PROMISE
         0x0c,                    //  Flags: END_HEADERS|PADDED
         0x00, 0x00, 0x00, 0x29,  // Stream: 41
         0x00,                    // PadLen: 0 trailing bytes
         0x00, 0x00, 0x00, 0x3a,  // Promise: 58
@@ skipping 15 matching lines @@
     SpdyPushPromiseIR push_promise(41, 58);
     push_promise.set_padding_len(1);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   }
 
   {
     // Test framing PUSH_PROMISE with 177 bytes of padding.
-    SpdyFramer framer;
-    framer.set_enable_compression(false);
+    SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
     const char kDescription[] = "PUSH_PROMISE frame with 177 bytes of padding";
 
     // frame-format off
     // clang-format off
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0xc7,        // Length: 199
         0x05,                    //   Type: PUSH_PROMISE
         0x0c,                    //  Flags: END_HEADERS|PADDED
         0x00, 0x00, 0x00, 0x2a,  // Stream: 42
         0xb0,                    // PadLen: 176 trailing bytes
@@ skipping 36 matching lines @@
     push_promise.set_padding_len(177);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   }
 }
 
 // Regression test for https://crbug.com/464748.
 TEST_P(SpdyFramerTest, GetNumberRequiredContinuationFrames) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   EXPECT_EQ(1u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 16374));
   EXPECT_EQ(2u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 16374 + 1));
   EXPECT_EQ(2u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 2 * 16374));
   EXPECT_EQ(3u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 2 * 16374 + 1));
 }
 
 TEST_P(SpdyFramerTest, CreateContinuationUncompressed) {
-  SpdyFramer framer;
-  framer.set_enable_compression(false);
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   const char kDescription[] = "CONTINUATION frame";
 
   // frame-format off
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x09,                    //   Type: CONTINUATION
       0x04,                    //  Flags: END_HEADERS
       0x00, 0x00, 0x00, 0x2a,  // Stream: 42
 
       0x00,              // Unindexed Entry
@@ skipping 22 matching lines @@
   continuation.set_end_headers(true);
 
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 // Test that if we send an unexpected CONTINUATION
 // we signal an error (but don't crash).
 TEST_P(SpdyFramerTest, SendUnexpectedContinuation) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   // frame-format off
   char kH2FrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x09,                    //   Type: CONTINUATION
       0x04,                    //  Flags: END_HEADERS
       0x00, 0x00, 0x00, 0x2a,  // Stream: 42
 
       0x00,              // Unindexed Entry
@@ skipping 18 matching lines @@
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, CreatePushPromiseThenContinuationUncompressed) {
   {
     // Test framing in a case such that a PUSH_PROMISE frame, with one byte of
     // padding, cannot hold all the data payload, which is overflowed to the
     // consecutive CONTINUATION frame.
-    SpdyFramer framer;
-    framer.set_enable_compression(false);
+    SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
     const char kDescription[] =
         "PUSH_PROMISE and CONTINUATION frames with one byte of padding";
 
     // frame-format off
     const unsigned char kPartialPushPromiseFrameData[] = {
         0x00, 0x3f, 0xf6,        // Length: 16374
         0x05,                    //   Type: PUSH_PROMISE
         0x08,                    //  Flags: PADDED
         0x00, 0x00, 0x00, 0x2a,  // Stream: 42
         0x00,                    // PadLen: 0 trailing bytes
@@ skipping 75 matching lines @@
 
     // Compare the CONTINUATION frame against the template.
     frame_data += TestSpdyVisitor::sent_control_frame_max_size();
     CompareCharArraysWithHexError(
         kDescription, frame_data, arraysize(kContinuationFrameData),
         kContinuationFrameData, arraysize(kContinuationFrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateAltSvc) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   const char kDescription[] = "ALTSVC frame";
   const char kType =
       static_cast<unsigned char>(SpdyConstants::SerializeFrameType(ALTSVC));
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x49, kType, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x06, 'o',
       'r',  'i',  'g',  'i',   'n',  'p',  'i',  'd',  '1',  '=',  '"',  'h',
       'o',  's',  't',  ':',   '4',  '4',  '3',  '"',  ';',  ' ',  'm',  'a',
       '=',  '5',  ',',  'p',   '%',  '2',  '2',  '%',  '3',  'D',  'i',  '%',
       '3',  'A',  'd',  '=',   '"',  'h',  '_',  '\\', '\\', 'o',  '\\', '"',
       's',  't',  ':',  '1',   '2',  '3',  '"',  ';',  ' ',  'm',  'a',  '=',
       '4',  '2',  ';',  ' ',   'v',  '=',  '"',  '2',  '4',  '"'};
   SpdyAltSvcIR altsvc_ir(3);
   altsvc_ir.set_origin("origin");
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector()));
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "p\"=i:d", "h_\\o\"st", 123, 42,
       SpdyAltSvcWireFormat::VersionVector{24}));
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, CreatePriority) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   const char kDescription[] = "PRIORITY frame";
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x02,                    //   Type: PRIORITY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x02,  // Stream: 2
       0x80, 0x00, 0x00, 0x01,  // Parent: 1 (Exclusive)
       0x10,                    // Weight: 17
   };
   SpdyPriorityIR priority_ir(2, 1, 17, true);
   SpdySerializedFrame frame(framer.SerializeFrame(priority_ir));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   SpdyPriorityIR priority2(2);
   priority2.set_parent_stream_id(1);
   priority2.set_weight(17);
   priority2.set_exclusive(true);
   frame = framer.SerializeFrame(priority2);
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdyHeadersIR headers_ir(1);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = true;
+  TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
   EXPECT_EQ(headers_ir.header_block(), visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdyHeadersIR headers_ir(1);
   headers_ir.set_fin(true);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = true;
+  TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
   EXPECT_EQ(headers_ir.header_block(), visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) {
-  SpdyFramer framer;
-  framer.set_enable_compression(false);
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   SpdyHeadersIR headers(1);
   headers.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   string big_value(kBigValueSize, 'x');
   headers.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
   EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 }
 
 TEST_P(SpdyFramerTest, MultipleContinuationFramesWithIterator) {
-  SpdyFramer framer;
-  framer.set_enable_compression(false);
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   auto headers = base::MakeUnique<SpdyHeadersIR>(1);
   headers->set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   string big_valuex(kBigValueSize, 'x');
   headers->SetHeader("aa", big_valuex);
   string big_valuez(kBigValueSize, 'z');
   headers->SetHeader("bb", big_valuez);
 
   SpdyFramer::SpdyHeaderFrameIterator frame_it(&framer, std::move(headers));
 
   EXPECT_TRUE(frame_it.HasNextFrame());
   SpdySerializedFrame headers_frame(frame_it.NextFrame());
   EXPECT_EQ(headers_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(headers_frame.data()),
       headers_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 
   EXPECT_TRUE(frame_it.HasNextFrame());
@@ skipping 21 matching lines @@
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 
   EXPECT_FALSE(frame_it.HasNextFrame());
 }
 
 TEST_P(SpdyFramerTest, TooLargePushPromiseFrameUsesContinuation) {
-  SpdyFramer framer;
-  framer.set_enable_compression(false);
+  SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   SpdyPushPromiseIR push_promise(1, 2);
   push_promise.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   string big_value(kBigValueSize, 'x');
   push_promise.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(framer.SerializePushPromise(push_promise));
   EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.push_promise_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 }
 
 // Check that the framer stops delivering header data chunks once the visitor
 // declares it doesn't want any more. This is important to guard against
 // "zip bomb" types of attacks.
 TEST_P(SpdyFramerTest, ControlFrameMuchTooLarge) {
   const size_t kHeaderBufferChunks = 4;
   const size_t kHeaderBufferSize =
       TestSpdyVisitor::header_data_chunk_max_size() * kHeaderBufferChunks;
   const size_t kBigValueSize = kHeaderBufferSize * 2;
   string big_value(kBigValueSize, 'x');
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdyHeadersIR headers(1);
   headers.set_fin(true);
   headers.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION);
   visitor.set_header_buffer_size(kHeaderBufferSize);
-  visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   // It's up to the visitor to ignore extraneous header data; the framer
   // won't throw an error.
   EXPECT_GT(visitor.header_bytes_received_, visitor.header_buffer_size_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameSizesAreValidated) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   // Create a GoAway frame that has a few extra bytes at the end.
   // We create enough overhead to overflow the framer's control frame buffer.
   ASSERT_LE(SpdyFramerPeer::ControlFrameBufferSize(), 250u);
   const size_t length = SpdyFramerPeer::ControlFrameBufferSize() + 1;
 
   // HTTP/2 GOAWAY frames are only bound by a minimal length, since they may
   // carry opaque data. Verify that minimal length is tested.
   ASSERT_GT(framer.GetGoAwayMinimumSize(), SpdyConstants::kFrameHeaderSize);
   const size_t less_than_min_length =
       framer.GetGoAwayMinimumSize() - SpdyConstants::kFrameHeaderSize - 1;
   ASSERT_LE(less_than_min_length, std::numeric_limits<unsigned char>::max());
   const unsigned char kH2Len = static_cast<unsigned char>(less_than_min_length);
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, kH2Len,        // Length: min length - 1
       0x07,                      //   Type: GOAWAY
       0x00,                      //  Flags: none
       0x00, 0x00, 0x00,   0x00,  // Stream: 0
       0x00, 0x00, 0x00,   0x00,  //   Last: 0
       0x00, 0x00, 0x00,          // Truncated Status Field
   };
   const size_t pad_length =
       length + SpdyConstants::kFrameHeaderSize - sizeof(kH2FrameData);
   string pad(pad_length, 'A');
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
 
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
   visitor.SimulateInFramer(reinterpret_cast<const unsigned char*>(pad.c_str()),
                            pad.length());
 
   EXPECT_EQ(1, visitor.error_count_);  // This generated an error.
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(0, visitor.goaway_count_);  // Frame not parsed.
 }
 
 TEST_P(SpdyFramerTest, ReadZeroLenSettingsFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdySettingsIR settings_ir;
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   SetFrameLength(&control_frame, 0);
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       framer.GetFrameHeaderSize());
   // Zero-len settings frames are permitted as of HTTP/2.
   EXPECT_EQ(0, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frames with invalid length.
 TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdySettingsIR settings_ir;
 
   // Add settings to more than fill the frame so that we don't get a buffer
   // overflow when calling SimulateInFramer() below.  These settings must be
   // distinct parameters because SpdySettingsIR has a map for settings, and will
   // collapse multiple copies of the same parameter.
   settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, false, false,
                          0x00000002);
   settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, false, false,
                          0x00000002);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   const size_t kNewLength = 8;
   SetFrameLength(&control_frame, kNewLength);
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       framer.GetFrameHeaderSize() + kNewLength);
   // Should generate an error, since its not possible to have a
   // settings frame of length kNewLength.
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of SETTINGS frames larger than the frame buffer size.
 TEST_P(SpdyFramerTest, ReadLargeSettingsFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdySettingsIR settings_ir;
   settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE,
                          false,  // persist
                          false,  // persisted
                          5);
   settings_ir.AddSetting(SETTINGS_ENABLE_PUSH,
                          false,  // persist
                          false,  // persisted
                          6);
   settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS,
                          false,  // persist
                          false,  // persisted
                          7);
 
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   EXPECT_LT(SpdyFramerPeer::ControlFrameBufferSize(), control_frame.size());
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
 
   // Read all at once.
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(3, visitor.setting_count_);
   EXPECT_EQ(1, visitor.settings_ack_sent_);
 
   // Read data in small chunks.
   size_t framed_data = 0;
   size_t unframed_data = control_frame.size();
   size_t kReadChunkSize = 5;  // Read five bytes at a time.
   while (unframed_data > 0) {
     size_t to_read = std::min(kReadChunkSize, unframed_data);
     visitor.SimulateInFramer(
         reinterpret_cast<unsigned char*>(control_frame.data() + framed_data),
         to_read);
     unframed_data -= to_read;
     framed_data += to_read;
   }
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(3 * 2, visitor.setting_count_);
   EXPECT_EQ(2, visitor.settings_ack_sent_);
 }
 
 // Tests handling of SETTINGS frame with duplicate entries.
 TEST_P(SpdyFramerTest, ReadDuplicateSettings) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x01,              //  Param: HEADER_TABLE_SIZE
       0x00, 0x00, 0x00, 0x02,  //  Value: 2
       0x00, 0x01,              //  Param: HEADER_TABLE_SIZE
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
       0x00, 0x03,              //  Param: MAX_CONCURRENT_STREAMS
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
   };
 
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
   // In HTTP/2, duplicate settings are allowed;
   // each setting replaces the previous value for that setting.
   EXPECT_EQ(3, visitor.setting_count_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.settings_ack_sent_);
 }
 
 // Tests handling of SETTINGS frame with a setting we don't recognize.
 TEST_P(SpdyFramerTest, ReadUnknownSettingsId) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x06,        // Length: 6
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x10,              //  Param: 16
       0x00, 0x00, 0x00, 0x02,  //  Value: 2
   };
 
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
   // In HTTP/2, we ignore unknown settings because of extensions.
   EXPECT_EQ(0, visitor.setting_count_);
   EXPECT_EQ(0, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frame with entries out of order.
 TEST_P(SpdyFramerTest, ReadOutOfOrderSettings) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x02,              //  Param: ENABLE_PUSH
       0x00, 0x00, 0x00, 0x02,  //  Value: 2
       0x00, 0x01,              //  Param: HEADER_TABLE_SIZE
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
       0x00, 0x03,              //  Param: MAX_CONCURRENT_STREAMS
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
   };
 
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
   // In HTTP/2, settings are allowed in any order.
   EXPECT_EQ(3, visitor.setting_count_);
   EXPECT_EQ(0, visitor.error_count_);
 }
 
 TEST_P(SpdyFramerTest, ProcessSettingsAckFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x00,        // Length: 0
       0x04,                    //   Type: SETTINGS
       0x01,                    //  Flags: ACK
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
   };
 
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.setting_count_);
   EXPECT_EQ(1, visitor.settings_ack_received_);
 }
 
 TEST_P(SpdyFramerTest, ProcessDataFrameWithPadding) {
   const int kPaddingLen = 119;
   const char data_payload[] = "hello";
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyDataIR data_ir(1, data_payload);
   data_ir.set_padding_len(kPaddingLen);
   SpdySerializedFrame frame(framer.SerializeData(data_ir));
 
   int bytes_consumed = 0;
 
   // Send the frame header.
   EXPECT_CALL(visitor,
@@ skipping 33 matching lines @@
   bytes_consumed += 100;
 
   // Send rest of the padding payload.
   EXPECT_CALL(visitor, OnStreamPadding(1, 18));
   CHECK_EQ(18u, framer.ProcessInput(frame.data() + bytes_consumed, 18));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_READY_FOR_FRAME);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
 }
 
 TEST_P(SpdyFramerTest, ReadWindowUpdate) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdySerializedFrame control_frame(
       framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2)));
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1u, visitor.last_window_update_stream_);
   EXPECT_EQ(2, visitor.last_window_update_delta_);
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedPushPromise) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdyPushPromiseIR push_promise(42, 57);
   push_promise.SetHeader("foo", "bar");
   push_promise.SetHeader("bar", "foofoo");
   SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = true;
+  TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION);
   visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                            frame.size());
   EXPECT_EQ(42u, visitor.last_push_promise_stream_);
   EXPECT_EQ(57u, visitor.last_push_promise_promised_stream_);
   EXPECT_EQ(push_promise.header_block(), visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadHeadersWithContinuation) {
   // frame-format off
   const unsigned char kInput[] = {
@@ skipping 29 matching lines @@
       'o',  'o',  'k',  'i',  'e',  // Name (continued)
       0x00,                         // Value Len: 0
       0x00,                         // Unindexed Entry
       0x04,                         // Name Len: 4
       'n',  'a',  'm',  'e',        // Name
       0x05,                         // Value Len: 5
       'v',  'a',  'l',  'u',  'e',  // Value
   };
   // frame-format on
 
-  SpdyFramer framer;
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
 
   EXPECT_THAT(
       visitor.headers_,
@@ skipping 34 matching lines @@
       'o',  'o',  'k',  'i',  'e',  // Name (continued)
       0x00,                         // Value Len: 0
       0x00,                         // Unindexed Entry
       0x04,                         // Name Len: 4
       'n',  'a',  'm',  'e',        // Name
       0x05,                         // Value Len: 5
       'v',  'a',  'l',  'u',  'e',  // Value
   };
   // frame-format on
 
-  SpdyFramer framer;
-  TestSpdyVisitor visitor;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(1, visitor.fin_flag_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
 
   EXPECT_THAT(
@@ skipping 26 matching lines @@
     0x00, 0x00, 0x12, 0x09,  // CONTINUATION
     0x04, 0x00, 0x00, 0x00,  // END_HEADERS
     0x01, 'o',  'o',  'k',   // Stream 1
     'i',  'e',  0x00, 0x00,
     0x04, 'n',  'a',  'm',
     'e',  0x05, 'v',  'a',
     'l',  'u',  'e',
   };
   // frame-format on
 
-  SpdyFramer framer;
-  TestSpdyVisitor visitor;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1u, visitor.last_push_promise_stream_);
   EXPECT_EQ(42u, visitor.last_push_promise_promised_stream_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
 
   EXPECT_THAT(
@@ skipping 19 matching lines @@
       0xa9,                    //   Type: UnknownFrameType(169)
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // Payload
       0x6f, 0x6b, 0x69, 0x65,  //
       0x08, 0x62, 0x61, 0x7a,  //
       0x3d, 0x62, 0x69, 0x6e,  //
       0x67, 0x00, 0x06, 0x63,  //
   };
 
-  SpdyFramer framer;
-  TestSpdyVisitor visitor;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   // Assume the unknown frame is allowed
   visitor.on_unknown_frame_result_ = true;
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
@@ skipping 15 matching lines @@
       0x09,                    //   Type: CONTINUATION
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x02,  // Stream: 2
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x08, 0x62, 0x61, 0x7a,  //
       0x3d, 0x62, 0x69, 0x6e,  //
       0x67, 0x00, 0x06, 0x63,  //
   };
 
-  SpdyFramer framer;
-  TestSpdyVisitor visitor;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ReadContinuationOutOfOrder) {
   const unsigned char kInput[] = {
       0x00, 0x00, 0x18,        // Length: 24
       0x09,                    //   Type: CONTINUATION
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
   };
 
-  SpdyFramer framer;
-  TestSpdyVisitor visitor;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ExpectContinuationReceiveData) {
   const unsigned char kInput[] = {
       0x00, 0x00, 0x10,        // Length: 16
       0x01,                    //   Type: HEADERS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
 
       0x00, 0x00, 0x00,        // Length: 0
       0x00,                    //   Type: DATA
       0x01,                    //  Flags: END_STREAM
       0x00, 0x00, 0x00, 0x04,  // Stream: 4
 
       0xde, 0xad, 0xbe, 0xef,  // Truncated Frame Header
   };
 
-  SpdyFramer framer;
-  TestSpdyVisitor visitor;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
   EXPECT_EQ(0, visitor.data_frame_count_);
@@ skipping 13 matching lines @@
       0x00, 0x00, 0x10,        // Length: 16
       0x01,                    //   Type: HEADERS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
   };
 
-  SpdyFramer framer;
-  TestSpdyVisitor visitor;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, ReadGarbage) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   unsigned char garbage_frame[256];
   memset(garbage_frame, ~0, sizeof(garbage_frame));
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(garbage_frame, sizeof(garbage_frame));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_P(SpdyFramerTest, ReadUnknownExtensionFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   // The unrecognized frame type should still have a valid length.
   const unsigned char unknown_frame[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0xff,                    //   Type: UnknownFrameType(255)
       0xff,                    //  Flags: 0xff
       0xff, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff (R-bit set)
       0xff, 0xff, 0xff, 0xff,  // Payload
       0xff, 0xff, 0xff, 0xff,  //
   };
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
 
   // Simulate the case where the stream id validation checks out.
   visitor.on_unknown_frame_result_ = true;
-  visitor.use_compression_ = false;
   visitor.SimulateInFramer(unknown_frame, arraysize(unknown_frame));
   EXPECT_EQ(0, visitor.error_count_);
 
   // Follow it up with a valid control frame to make sure we handle
   // subsequent frames correctly.
   SpdySettingsIR settings_ir;
   settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE,
                          false,  // persist
                          false,  // persisted
                          10);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1u, static_cast<unsigned>(visitor.setting_count_));
   EXPECT_EQ(1u, static_cast<unsigned>(visitor.settings_ack_sent_));
 }
 
 TEST_P(SpdyFramerTest, ReadGarbageWithValidLength) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0xff,                    //   Type: UnknownFrameType(255)
       0xff,                    //  Flags: 0xff
       0xff, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff (R-bit set)
       0xff, 0xff, 0xff, 0xff,  // Payload
       0xff, 0xff, 0xff, 0xff,  //
   };
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kFrameData, arraysize(kFrameData));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_P(SpdyFramerTest, ReadGarbageHPACKEncoding) {
   const unsigned char kInput[] = {
       0x00, 0x12, 0x01,        // Length: 4609
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x01, 0xef,  // Stream: 495
       0xef, 0xff,              //  Param: 61439
       0xff, 0xff, 0xff, 0xff,  //  Value: 4294967295
       0xff, 0xff,              //  Param: 0xffff
       0xff, 0xff, 0xff, 0xff,  //  Value: 4294967295
       0xff, 0xff, 0xff, 0xff,  // Settings (Truncated)
       0xff,                    //
   };
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kInput, arraysize(kInput));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_P(SpdyFramerTest, SizesTest) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   EXPECT_EQ(9u, framer.GetDataFrameMinimumSize());
   EXPECT_EQ(9u, framer.GetFrameHeaderSize());
   EXPECT_EQ(13u, framer.GetRstStreamMinimumSize());
   EXPECT_EQ(9u, framer.GetSettingsMinimumSize());
   EXPECT_EQ(17u, framer.GetPingSize());
   EXPECT_EQ(17u, framer.GetGoAwayMinimumSize());
   EXPECT_EQ(9u, framer.GetHeadersMinimumSize());
   EXPECT_EQ(13u, framer.GetWindowUpdateSize());
   EXPECT_EQ(9u, framer.GetBlockedSize());
   EXPECT_EQ(13u, framer.GetPushPromiseMinimumSize());
@@ skipping 104 matching lines @@
 
 TEST_P(SpdyFramerTest, DataFrameFlagsV4) {
   uint8_t valid_data_flags = DATA_FLAG_FIN | DATA_FLAG_PADDED;
 
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer;
+    SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
 
     SpdyDataIR data_ir(1, "hello");
     SpdySerializedFrame frame(framer.SerializeData(data_ir));
     SetFrameFlags(&frame, flags);
 
     if (flags & ~valid_data_flags) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnDataFrameHeader(1, 5, flags & DATA_FLAG_FIN));
@@ skipping 28 matching lines @@
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, RstStreamFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer;
+    SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
 
     SpdyRstStreamIR rst_stream(13, RST_STREAM_CANCEL);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     SetFrameFlags(&frame, flags);
 
     EXPECT_CALL(visitor, OnRstStream(13, RST_STREAM_CANCEL));
 
     framer.ProcessInput(frame.data(), frame.size());
 
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, SettingsFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer;
+    SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
 
     SpdySettingsIR settings_ir;
     settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0, 0, 16);
     SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
     SetFrameFlags(&frame, flags);
 
     if (flags & SETTINGS_FLAG_ACK) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
@@ skipping 17 matching lines @@
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, GoawayFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer;
+    SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
 
     SpdyGoAwayIR goaway_ir(97, GOAWAY_OK, "test");
     SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
     SetFrameFlags(&frame, flags);
 
     EXPECT_CALL(visitor, OnGoAway(97, GOAWAY_OK));
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, HeadersFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer;
+    SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
 
     SpdyHeadersIR headers_ir(57);
     if (flags & HEADERS_FLAG_PRIORITY) {
       headers_ir.set_weight(3);
       headers_ir.set_has_priority(true);
       headers_ir.set_parent_stream_id(5);
       headers_ir.set_exclusive(true);
     }
     headers_ir.SetHeader("foo", "bar");
@@ skipping 36 matching lines @@
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, PingFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer;
+    SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
 
     SpdySerializedFrame frame(framer.SerializePing(SpdyPingIR(42)));
     SetFrameFlags(&frame, flags);
 
     if (flags & PING_FLAG_ACK) {
       EXPECT_CALL(visitor, OnPing(42, true));
     } else {
       EXPECT_CALL(visitor, OnPing(42, false));
     }
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, WindowUpdateFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer;
+    SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
 
     SpdySerializedFrame frame(
         framer.SerializeWindowUpdate(SpdyWindowUpdateIR(4, 1024)));
     SetFrameFlags(&frame, flags);
 
     EXPECT_CALL(visitor, OnWindowUpdate(4, 1024));
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, PushPromiseFrameFlags) {
   const SpdyStreamId client_id = 123;   // Must be odd.
   const SpdyStreamId promised_id = 22;  // Must be even.
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
-    SpdyFramer framer;
+    SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor,
                 OnSendCompressedFrame(client_id, PUSH_PROMISE, _, _));
 
     SpdyPushPromiseIR push_promise(client_id, promised_id);
     push_promise.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     // TODO(jgraettinger): Add padding to SpdyPushPromiseIR,
@@ skipping 17 matching lines @@
 }
 
 TEST_P(SpdyFramerTest, ContinuationFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
-    SpdyFramer framer;
+    SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, HEADERS, _, _));
     EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, HEADERS, _));
     EXPECT_CALL(visitor, OnHeaders(42, false, 0, 0, false, false, false));
     EXPECT_CALL(visitor, OnHeaderFrameStart(42)).Times(1);
 
     SpdyHeadersIR headers_ir(42);
     headers_ir.SetHeader("foo", "bar");
@@ skipping 47 matching lines @@
   };
   const unsigned char kH2RstStreamNumStatusCodes[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0xff,  //  Error: 255
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_NO_ERROR));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2RstStreamInvalid),
                       arraysize(kH2RstStreamInvalid));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 
   framer.Reset();
 
   EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INTERNAL_ERROR));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2RstStreamNumStatusCodes),
                       arraysize(kH2RstStreamNumStatusCodes));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test handling of GOAWAY frames with out-of-bounds status code.
 TEST_P(SpdyFramerTest, GoAwayStatusBounds) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x0a,        // Length: 10
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x00, 0x00, 0x01,  //   Last: 1
       0xff, 0xff, 0xff, 0xff,  //  Error: 0xffffffff
       0x47, 0x41,              // Description
   };
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
@@ skipping 12 matching lines @@
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0xff, 0xff, 0xff, 0xff,  //   Last: 0x7fffffff (R-bit set)
       0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnGoAway(0x7fffffff, GOAWAY_OK));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2FrameData),
                       arraysize(kH2FrameData));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnBlocked) {
   const SpdyStreamId kStreamId = 0;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnBlocked(kStreamId));
 
   SpdyBlockedIR blocked_ir(0);
   SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir));
   framer.ProcessInput(frame.data(), framer.GetBlockedSize());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvc) {
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyAltSvcWireFormat::AlternativeService altsvc1(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeService altsvc2(
       "p\"=i:d", "h_\\o\"st", 123, 42, SpdyAltSvcWireFormat::VersionVector{24});
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc1);
   altsvc_vector.push_back(altsvc2);
   EXPECT_CALL(visitor,
               OnAltSvc(kStreamId, StringPiece("o_r|g!n"), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_origin("o_r|g!n");
   altsvc_ir.add_altsvc(altsvc1);
   altsvc_ir.add_altsvc(altsvc2);
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvcNoOrigin) {
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyAltSvcWireFormat::AlternativeService altsvc1(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeService altsvc2(
       "p\"=i:d", "h_\\o\"st", 123, 42, SpdyAltSvcWireFormat::VersionVector{24});
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc1);
   altsvc_vector.push_back(altsvc2);
   EXPECT_CALL(visitor, OnAltSvc(kStreamId, StringPiece(""), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.add_altsvc(altsvc1);
   altsvc_ir.add_altsvc(altsvc2);
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvcEmptyProtocolId) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_origin("o1");
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector()));
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "", "h1", 443, 10, SpdyAltSvcWireFormat::VersionVector()));
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvcBadLengths) {
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyAltSvcWireFormat::AlternativeService altsvc(
       "pid", "h1", 443, 10, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc);
   EXPECT_CALL(visitor, OnAltSvc(kStreamId, StringPiece("o1"), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_origin("o1");
   altsvc_ir.add_altsvc(altsvc);
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Tests handling of ALTSVC frames delivered in small chunks.
 TEST_P(SpdyFramerTest, ReadChunkedAltSvcFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdyAltSvcIR altsvc_ir(1);
   SpdyAltSvcWireFormat::AlternativeService altsvc1(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeService altsvc2(
       "p\"=i:d", "h_\\o\"st", 123, 42, SpdyAltSvcWireFormat::VersionVector{24});
   altsvc_ir.add_altsvc(altsvc1);
   altsvc_ir.add_altsvc(altsvc2);
 
   SpdySerializedFrame control_frame(framer.SerializeAltSvc(altsvc_ir));
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
 
   // Read data in small chunks.
   size_t framed_data = 0;
   size_t unframed_data = control_frame.size();
   size_t kReadChunkSize = 5;  // Read five bytes at a time.
   while (unframed_data > 0) {
     size_t to_read = std::min(kReadChunkSize, unframed_data);
     visitor.SimulateInFramer(
         reinterpret_cast<unsigned char*>(control_frame.data() + framed_data),
         to_read);
     unframed_data -= to_read;
     framed_data += to_read;
   }
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.altsvc_count_);
   ASSERT_EQ(2u, visitor.test_altsvc_ir_.altsvc_vector().size());
   EXPECT_TRUE(visitor.test_altsvc_ir_.altsvc_vector()[0] == altsvc1);
   EXPECT_TRUE(visitor.test_altsvc_ir_.altsvc_vector()[1] == altsvc2);
 }
 
 // Tests handling of PRIORITY frames.
 TEST_P(SpdyFramerTest, ReadPriority) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdyPriorityIR priority(3, 1, 256, false);
   SpdySerializedFrame frame(framer.SerializePriority(priority));
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   framer.set_visitor(&visitor);
   EXPECT_CALL(visitor, OnPriority(3, 1, 256, false));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   // TODO(mlavan): once we actually maintain a priority tree,
   // check that state is adjusted correctly.
 }
 
 // Tests handling of PRIORITY frame with incorrect size.
 TEST_P(SpdyFramerTest, ReadIncorrectlySizedPriority) {
   // PRIORITY frame of size 4, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x02,                    //   Type: PRIORITY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x00, 0x01,  // Priority (Truncated)
   };
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of PING frame with incorrect size.
 TEST_P(SpdyFramerTest, ReadIncorrectlySizedPing) {
   // PING frame of size 4, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x06,                    //   Type: PING
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x00, 0x00, 0x01,  // Ping (Truncated)
   };
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of WINDOW_UPDATE frame with incorrect size.
 TEST_P(SpdyFramerTest, ReadIncorrectlySizedWindowUpdate) {
   // WINDOW_UPDATE frame of size 3, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x03,        // Length: 3
       0x08,                    //   Type: WINDOW_UPDATE
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x01,        // WindowUpdate (Truncated)
   };
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of RST_STREAM frame with incorrect size.
 TEST_P(SpdyFramerTest, ReadIncorrectlySizedRstStream) {
   // RST_STREAM frame of size 3, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x03,        // Length: 3
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x01,        // RstStream (Truncated)
   };
 
-  TestSpdyVisitor visitor;
+  TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Test that SpdyFramer processes, by default, all passed input in one call
 // to ProcessInput (i.e. will not be calling set_process_single_input_frame()).
 TEST_P(SpdyFramerTest, ProcessAllInput) {
-  SpdyFramer framer;
-  std::unique_ptr<TestSpdyVisitor> visitor(new TestSpdyVisitor);
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
+  std::unique_ptr<TestSpdyVisitor> visitor(
+      new TestSpdyVisitor(SpdyFramer::DISABLE_COMPRESSION));
   framer.set_visitor(visitor.get());
 
   // Create two input frames.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
   SpdySerializedFrame headers_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
@@ skipping 27 matching lines @@
   EXPECT_EQ(1, visitor->headers_frame_count_);
   EXPECT_EQ(1, visitor->data_frame_count_);
   EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
 }
 
 // Test that SpdyFramer stops after processing a full frame if
 // process_single_input_frame is set. Input to ProcessInput has two frames, but
 // only processes the first when we give it the first frame split at any point,
 // or give it more than one frame in the input buffer.
 TEST_P(SpdyFramerTest, ProcessAtMostOneFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_process_single_input_frame(true);
   std::unique_ptr<TestSpdyVisitor> visitor;
 
   // Create two input frames.
   const char four_score[] = "Four score and ...";
   SpdyDataIR four_score_ir(1, four_score);
   SpdySerializedFrame four_score_frame(framer.SerializeData(four_score_ir));
 
   SpdyHeadersIR headers(2);
   headers.SetHeader("alpha", "beta");
@@ skipping 17 matching lines @@
   input_buffer.append(frame1.data(), frame1_size);
   input_buffer.append(frame2.data(), frame2_size);
 
   const char* buf = input_buffer.data();
   const size_t buf_size = input_buffer.size();
 
   VLOG(1) << "buf_size = " << buf_size;
 
   for (size_t first_size = 0; first_size <= buf_size; ++first_size) {
     VLOG(1) << "first_size = " << first_size;
-    visitor.reset(new TestSpdyVisitor);
+    visitor.reset(new TestSpdyVisitor(SpdyFramer::DISABLE_COMPRESSION));
     framer.set_visitor(visitor.get());
 
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
 
     size_t processed_first = framer.ProcessInput(buf, first_size);
     if (first_size < frame1_size) {
       EXPECT_EQ(first_size, processed_first);
 
       if (first_size == 0) {
         EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
@@ skipping 22 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net