Created a new class SpdyTestStateHelper to serve as a helper to manage the state of a number of SPD…

net/spdy/buffered_spdy_framer_spdy2_unittest.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/buffered_spdy_framer.h"
 
 #include "net/spdy/spdy_test_util_spdy2.h"
 #include "testing/platform_test.h"
 
 using namespace net::test_spdy2;
@@ skipping 125 matching lines @@
   SpdyStreamId header_stream_id_;
 
   // Headers from OnSyn, OnSynReply and OnHeaders for verification.
   SpdyHeaderBlock headers_;
 };
 
 }  // namespace
 
 class BufferedSpdyFramerSpdy2Test : public PlatformTest {
  protected:
-  void EnableCompression(bool enabled) {
-    SpdyFramer::set_enable_compression_default(enabled);
-  }
-
   // Returns true if the two header blocks have equivalent content.
   bool CompareHeaderBlocks(const SpdyHeaderBlock* expected,
                            const SpdyHeaderBlock* actual) {
     if (expected->size() != actual->size()) {
       LOG(ERROR) << "Expected " << expected->size() << " headers; actually got "
                  << actual->size() << ".";
       return false;
     }
     for (SpdyHeaderBlock::const_iterator it = expected->begin();
          it != expected->end();
          ++it) {
       SpdyHeaderBlock::const_iterator it2 = actual->find(it->first);
       if (it2 == actual->end()) {
         LOG(ERROR) << "Expected header name '" << it->first << "'.";
         return false;
       }
       if (it->second.compare(it2->second) != 0) {
         LOG(ERROR) << "Expected header named '" << it->first
                    << "' to have a value of '" << it->second
                    << "'. The actual value received was '" << it2->second
                    << "'.";
         return false;
       }
     }
     return true;
   }
+
+ private:
+  SpdyTestStateHelper spdy_state_;
 };
 
 TEST_F(BufferedSpdyFramerSpdy2Test, OnSetting) {
-  EnableCompression(false);
-
   SpdyFramer framer(2);
   SpdySettings settings;
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 1), 0x00000002));
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 1), 0x00000003));
 
   scoped_ptr<SpdyFrame> control_frame(framer.CreateSettings(settings));
   TestBufferedSpdyVisitor visitor;
 
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(1, visitor.setting_count_);
 }
 
 TEST_F(BufferedSpdyFramerSpdy2Test, ReadSynStreamHeaderBlock) {
-  EnableCompression(false);
-
   SpdyHeaderBlock headers;
   headers["aa"] = "vv";
   headers["bb"] = "ww";
   BufferedSpdyFramer framer(2);
   scoped_ptr<SpdySynStreamControlFrame> control_frame(
       framer.CreateSynStream(1,                        // stream_id
                              0,                        // associated_stream_id
                              1,                        // priority
                              CONTROL_FLAG_NONE,
                              true,                     // compress
                              &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.get()->data()),
       control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_F(BufferedSpdyFramerSpdy2Test, ReadSynReplyHeaderBlock) {
-  EnableCompression(false);
-
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
   BufferedSpdyFramer framer(2);
   scoped_ptr<SpdySynReplyControlFrame> control_frame(
       framer.CreateSynReply(1,                        // stream_id
                             CONTROL_FLAG_NONE,
                             true,                     // compress
                             &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.get()->data()),
        control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(1, visitor.syn_reply_frame_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_F(BufferedSpdyFramerSpdy2Test, ReadHeadersHeaderBlock) {
-  EnableCompression(false);
-
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
   BufferedSpdyFramer framer(2);
   scoped_ptr<SpdyHeadersControlFrame> control_frame(
       framer.CreateHeaders(1,                        // stream_id
                            CONTROL_FLAG_NONE,
                            true,                    // compress
                            &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.get()->data()),
        control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 }  // namespace spdy