Move a number of static variables SPDY to HttpNetworkSession::Params.

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;
 
 namespace net {
 
 namespace {
 
 class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
  public:
   TestBufferedSpdyVisitor()
-    : buffered_spdy_framer_(2),
-      error_count_(0),
-      setting_count_(0),
-      syn_frame_count_(0),
-      syn_reply_frame_count_(0),
-      headers_frame_count_(0),
-      header_stream_id_(-1) {
+      : buffered_spdy_framer_(2, true),
+        error_count_(0),
+        setting_count_(0),
+        syn_frame_count_(0),
+        syn_reply_frame_count_(0),
+        headers_frame_count_(0),
+        header_stream_id_(-1) {
   }
 
   void OnError(SpdyFramer::SpdyError error_code) {
     LOG(INFO) << "SpdyFramer Error: " << error_code;
     error_count_++;
   }
 
   void OnStreamError(SpdyStreamId stream_id,
                      const std::string& description) {
     LOG(INFO) << "SpdyFramer Error on stream: " << stream_id  << " "
@@ skipping 131 matching lines @@
       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) {
   SpdyFramer framer(2);
   SettingsMap settings;
   settings[SETTINGS_UPLOAD_BANDWIDTH] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, 0x00000002);
   settings[SETTINGS_DOWNLOAD_BANDWIDTH] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, 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(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.setting_count_);
 }
 
 TEST_F(BufferedSpdyFramerSpdy2Test, ReadSynStreamHeaderBlock) {
   SpdyHeaderBlock headers;
   headers["aa"] = "vv";
   headers["bb"] = "ww";
-  BufferedSpdyFramer framer(2);
+  BufferedSpdyFramer framer(2, true);
   scoped_ptr<SpdySynStreamControlFrame> control_frame(
       framer.CreateSynStream(1,                        // stream_id
                              0,                        // associated_stream_id
                              1,                        // priority
                              0,                        // credential_slot
                              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) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
-  BufferedSpdyFramer framer(2);
+  BufferedSpdyFramer framer(2, true);
   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) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
-  BufferedSpdyFramer framer(2);
+  BufferedSpdyFramer framer(2, true);
   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 net