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

net/spdy/spdy_test_util_spdy3.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_test_util_spdy3.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
-#include "crypto/ec_private_key.h"
-#include "crypto/ec_signature_creator.h"
 #include "net/base/mock_cert_verifier.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/spdy/buffered_spdy_framer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 namespace test_spdy3 {
 
 namespace {
 
 // Parses a URL into the scheme, host, and path components required for a
 // SPDY request.
 void ParseUrl(const char* const url, std::string* scheme, std::string* host,
               std::string* path) {
   GURL gurl(url);
   path->assign(gurl.PathForRequest());
   scheme->assign(gurl.scheme());
   host->assign(gurl.host());
   if (gurl.has_port()) {
     host->append(":");
     host->append(gurl.port());
   }
 }
 
-// An ECSignatureCreator that returns deterministic signatures.
-class MockECSignatureCreator : public crypto::ECSignatureCreator {
- public:
-  explicit MockECSignatureCreator(crypto::ECPrivateKey* key) : key_(key) {}
+}  // namespace
 
-  virtual bool Sign(const uint8* data,
-                    int data_len,
-                    std::vector<uint8>* signature) OVERRIDE {
-    std::vector<uint8> private_key_value;
-    key_->ExportValue(&private_key_value);
-    std::string head = "fakesignature";
-    std::string tail = "/fakesignature";
 
-    signature->clear();
-    signature->insert(signature->end(), head.begin(), head.end());
-    signature->insert(signature->end(), private_key_value.begin(),
-                      private_key_value.end());
-    signature->insert(signature->end(), '-');
-    signature->insert(signature->end(), data, data + data_len);
-    signature->insert(signature->end(), tail.begin(), tail.end());
-    return true;
-  }
+MockECSignatureCreator::MockECSignatureCreator(crypto::ECPrivateKey* key)
+    : key_(key) {
+}
 
-  virtual bool DecodeSignature(const std::vector<uint8>& signature,
-                               std::vector<uint8>* out_raw_sig) {
-    *out_raw_sig = signature;
-    return true;
-  }
+bool MockECSignatureCreator::Sign(const uint8* data,
+                                  int data_len,
+                                  std::vector<uint8>* signature) {
+  std::vector<uint8> private_key_value;
+  key_->ExportValue(&private_key_value);
+  std::string head = "fakesignature";
+  std::string tail = "/fakesignature";
 
- private:
-  crypto::ECPrivateKey* key_;
+  signature->clear();
+  signature->insert(signature->end(), head.begin(), head.end());
+  signature->insert(signature->end(), private_key_value.begin(),
+                    private_key_value.end());
+  signature->insert(signature->end(), '-');
+  signature->insert(signature->end(), data, data + data_len);
+  signature->insert(signature->end(), tail.begin(), tail.end());
+  return true;
+}
 
-  DISALLOW_COPY_AND_ASSIGN(MockECSignatureCreator);
-};
+bool MockECSignatureCreator::DecodeSignature(
+    const std::vector<uint8>& signature,
+    std::vector<uint8>* out_raw_sig) {
+  *out_raw_sig = signature;
+  return true;
+}
 
-// An ECSignatureCreatorFactory creates MockECSignatureCreator.
-class MockECSignatureCreatorFactory : public crypto::ECSignatureCreatorFactory {
- public:
-  MockECSignatureCreatorFactory() {}
-  virtual ~MockECSignatureCreatorFactory() {}
+MockECSignatureCreatorFactory::MockECSignatureCreatorFactory() {
+  crypto::ECSignatureCreator::SetFactoryForTesting(this);
+}
 
-  virtual crypto::ECSignatureCreator* Create(
-      crypto::ECPrivateKey* key) OVERRIDE {
-    return new MockECSignatureCreator(key);
-  }
+MockECSignatureCreatorFactory::~MockECSignatureCreatorFactory() {
+  crypto::ECSignatureCreator::SetFactoryForTesting(NULL);
+}
 
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockECSignatureCreatorFactory);
-};
-
-}  // namespace
+crypto::ECSignatureCreator* MockECSignatureCreatorFactory::Create(
+    crypto::ECPrivateKey* key) {
+  return new MockECSignatureCreator(key);
+}
 
 // Chop a frame into an array of MockWrites.
 // |data| is the frame to chop.
 // |length| is the length of the frame to chop.
 // |num_chunks| is the number of chunks to create.
 MockWrite* ChopWriteFrame(const char* data, int length, int num_chunks) {
   MockWrite* chunks = new MockWrite[num_chunks];
   int chunk_size = length / num_chunks;
   for (int index = 0; index < num_chunks; index++) {
     const char* ptr = data + (index * chunk_size);
@@ skipping 112 matching lines @@
 
 // Construct a SPDY packet.
 // |head| is the start of the packet, up to but not including
 // the header value pairs.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // |tail| is any (relatively constant) header-value pairs to add.
 // |buffer| is the buffer we're filling in.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyPacket(const SpdyHeaderInfo& header_info,
-                                     const char* const extra_headers[],
-                                     int extra_header_count,
-                                     const char* const tail[],
-                                     int tail_header_count) {
-  BufferedSpdyFramer framer(3);
+                               const char* const extra_headers[],
+                               int extra_header_count,
+                               const char* const tail[],
+                               int tail_header_count) {
+  BufferedSpdyFramer framer(3, header_info.compressed);
   SpdyHeaderBlock headers;
   // Copy in the extra headers to our map.
   AppendHeadersToSpdyFrame(extra_headers, extra_header_count, &headers);
   // Copy in the tail headers to our map.
   if (tail && tail_header_count)
     AppendHeadersToSpdyFrame(tail, tail_header_count, &headers);
   SpdyFrame* frame = NULL;
   switch (header_info.kind) {
     case SYN_STREAM:
       frame = framer.CreateSynStream(header_info.id, header_info.assoc_id,
@@ skipping 19 matching lines @@
                                      header_info.data_flags);
       break;
   }
   return frame;
 }
 
 // Construct an expected SPDY SETTINGS frame.
 // |settings| are the settings to set.
 // Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdySettings(const SettingsMap& settings) {
-  BufferedSpdyFramer framer(3);
+  BufferedSpdyFramer framer(3, false);
   return framer.CreateSettings(settings);
 }
 
 // Construct an expected SPDY CREDENTIAL frame.
 // |credential| is the credential to sen.
 // Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdyCredential(
     const SpdyCredential& credential) {
-  BufferedSpdyFramer framer(3);
+  BufferedSpdyFramer framer(3, false);
   return framer.CreateCredentialFrame(credential);
 }
 
 // Construct a SPDY PING frame.
 // Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdyPing(uint32 ping_id) {
-  BufferedSpdyFramer framer(3);
+  BufferedSpdyFramer framer(3, false);
   return framer.CreatePingFrame(ping_id);
 }
 
 // Construct a SPDY GOAWAY frame.
 // Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdyGoAway() {
-  BufferedSpdyFramer framer(3);
+  BufferedSpdyFramer framer(3, false);
   return framer.CreateGoAway(0, GOAWAY_OK);
 }
 
 // Construct a SPDY WINDOW_UPDATE frame.
 // Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdyWindowUpdate(
     const SpdyStreamId stream_id, uint32 delta_window_size) {
-  BufferedSpdyFramer framer(3);
+  BufferedSpdyFramer framer(3, false);
   return framer.CreateWindowUpdate(stream_id, delta_window_size);
 }
 
 // Construct a SPDY RST_STREAM frame.
 // Returns the constructed frame.  The caller takes ownership of the frame.
 SpdyFrame* ConstructSpdyRstStream(SpdyStreamId stream_id,
-                                        SpdyStatusCodes status) {
-  BufferedSpdyFramer framer(3);
+                                  SpdyStatusCodes status) {
+  BufferedSpdyFramer framer(3, false);
   return framer.CreateRstStream(stream_id, status);
 }
 
 // Construct a single SPDY header entry, for validation.
 // |extra_headers| are the extra header-value pairs.
 // |buffer| is the buffer we're filling in.
 // |index| is the index of the header we want.
 // Returns the number of bytes written into |buffer|.
 int ConstructSpdyHeader(const char* const extra_headers[],
                         int extra_header_count,
@@ skipping 24 matching lines @@
     this_value = "";
   int n = base::snprintf(buffer,
                          buffer_length,
                          "%s: %s\r\n",
                          this_header,
                          this_value);
   return n;
 }
 
 SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
-                                           int extra_header_count,
-                                           bool compressed,
-                                           int stream_id,
-                                           RequestPriority request_priority,
-                                           SpdyControlType type,
-                                           SpdyControlFlags flags,
-                                           const char* const* kHeaders,
-                                           int kHeadersSize) {
+                                     int extra_header_count,
+                                     bool compressed,
+                                     int stream_id,
+                                     RequestPriority request_priority,
+                                     SpdyControlType type,
+                                     SpdyControlFlags flags,
+                                     const char* const* kHeaders,
+                                     int kHeadersSize) {
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    compressed,
                                    stream_id,
                                    request_priority,
                                    type,
                                    flags,
                                    kHeaders,
                                    kHeadersSize,
                                    0);
 }
 
 SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
-                                           int extra_header_count,
-                                           bool compressed,
-                                           int stream_id,
-                                           RequestPriority request_priority,
-                                           SpdyControlType type,
-                                           SpdyControlFlags flags,
-                                           const char* const* kHeaders,
-                                           int kHeadersSize,
-                                           int associated_stream_id) {
+                                     int extra_header_count,
+                                     bool compressed,
+                                     int stream_id,
+                                     RequestPriority request_priority,
+                                     SpdyControlType type,
+                                     SpdyControlFlags flags,
+                                     const char* const* kHeaders,
+                                     int kHeadersSize,
+                                     int associated_stream_id) {
   const SpdyHeaderInfo kSynStartHeader = {
     type,                         // Kind = Syn
     stream_id,                    // Stream ID
     associated_stream_id,         // Associated stream ID
     ConvertRequestPriorityToSpdyPriority(request_priority, 3),
                                   // Priority
     0,                            // Credential Slot
     flags,                        // Control Flags
     compressed,                   // Compressed
-    INVALID,                // Status
+    INVALID,                      // Status
     NULL,                         // Data
     0,                            // Length
-    DATA_FLAG_NONE          // Data Flags
+    DATA_FLAG_NONE                // Data Flags
   };
   return ConstructSpdyPacket(kSynStartHeader,
                              extra_headers,
                              extra_header_count,
                              kHeaders,
                              kHeadersSize / 2);
 }
 
 // Constructs a standard SPDY GET SYN packet, optionally compressed
 // for the url |url|.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGet(const char* const url,
-                                  bool compressed,
-                                  int stream_id,
-                                  RequestPriority request_priority) {
+                            bool compressed,
+                            int stream_id,
+                            RequestPriority request_priority) {
   const SpdyHeaderInfo kSynStartHeader = {
-    SYN_STREAM,             // Kind = Syn
+    SYN_STREAM,                   // Kind = Syn
     stream_id,                    // Stream ID
     0,                            // Associated stream ID
     ConvertRequestPriorityToSpdyPriority(request_priority, 3),
                                   // Priority
     0,                            // Credential Slot
-    CONTROL_FLAG_FIN,       // Control Flags
+    CONTROL_FLAG_FIN,             // Control Flags
     compressed,                   // Compressed
-    INVALID,                // Status
+    INVALID,                      // Status
     NULL,                         // Data
     0,                            // Length
-    DATA_FLAG_NONE          // Data Flags
+    DATA_FLAG_NONE                // Data Flags
   };
 
   std::string scheme, host, path;
   ParseUrl(url, &scheme, &host, &path);
   const char* const headers[] = {
     ":method", "GET",
     ":path", path.c_str(),
     ":host", host.c_str(),
     ":scheme", scheme.c_str(),
     ":version", "HTTP/1.1"
   };
   return ConstructSpdyPacket(
       kSynStartHeader,
       NULL,
       0,
       headers,
       arraysize(headers) / 2);
 }
 
 // Constructs a standard SPDY GET SYN packet, optionally compressed.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
-                                  int extra_header_count,
-                                  bool compressed,
-                                  int stream_id,
-                                  RequestPriority request_priority) {
+                            int extra_header_count,
+                            bool compressed,
+                            int stream_id,
+                            RequestPriority request_priority) {
   return ConstructSpdyGet(extra_headers, extra_header_count, compressed,
                           stream_id, request_priority, true);
 }
 
 // Constructs a standard SPDY GET SYN packet, optionally compressed.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
-                                  int extra_header_count,
-                                  bool compressed,
-                                  int stream_id,
-                                  RequestPriority request_priority,
-                                  bool direct) {
+                            int extra_header_count,
+                            bool compressed,
+                            int stream_id,
+                            RequestPriority request_priority,
+                            bool direct) {
   const char* const kStandardGetHeaders[] = {
-    ":method",
-    "GET",
-    ":host",
-    "www.google.com",
-    ":scheme",
-    "http",
-    ":version",
-    "HTTP/1.1",
-    ":path",
-    (direct ? "/" : "/")
+    ":method", "GET",
+    ":host", "www.google.com",
+    ":scheme", "http",
+    ":version", "HTTP/1.1",
+    ":path", (direct ? "/" : "/")
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    compressed,
                                    stream_id,
                                    request_priority,
                                    SYN_STREAM,
                                    CONTROL_FLAG_FIN,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
 // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
 SpdyFrame* ConstructSpdyConnect(const char* const extra_headers[],
-                                      int extra_header_count,
-                                      int stream_id) {
+                                int extra_header_count,
+                                int stream_id) {
   const char* const kConnectHeaders[] = {
     ":method", "CONNECT",
     ":path", "www.google.com:443",
     ":host", "www.google.com",
     ":version", "HTTP/1.1",
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    /*compressed*/ false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    kConnectHeaders,
                                    arraysize(kConnectHeaders));
 }
 
 // Constructs a standard SPDY push SYN packet.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
-                                   int extra_header_count,
-                                   int stream_id,
-                                   int associated_stream_id) {
+                             int extra_header_count,
+                             int stream_id,
+                             int associated_stream_id) {
   const char* const kStandardPushHeaders[] = {
     "hello", "bye",
     ":status",  "200",
     ":version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    kStandardPushHeaders,
                                    arraysize(kStandardPushHeaders),
                                    associated_stream_id);
 }
 
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
-                                   int extra_header_count,
-                                   int stream_id,
-                                   int associated_stream_id,
-                                   const char* url) {
+                             int extra_header_count,
+                             int stream_id,
+                             int associated_stream_id,
+                             const char* url) {
   std::string scheme, host, path;
   ParseUrl(url, &scheme, &host, &path);
   const char* const headers[] = {
     "hello",    "bye",
     ":status",  "200 OK",
     ":version", "HTTP/1.1",
     ":path",    path.c_str(),
     ":host",    host.c_str(),
     ":scheme",  scheme.c_str(),
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    headers,
                                    arraysize(headers),
                                    associated_stream_id);
 
 }
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
-                                   int extra_header_count,
-                                   int stream_id,
-                                   int associated_stream_id,
-                                   const char* url,
-                                   const char* status,
-                                   const char* location) {
+                             int extra_header_count,
+                             int stream_id,
+                             int associated_stream_id,
+                             const char* url,
+                             const char* status,
+                             const char* location) {
   std::string scheme, host, path;
   ParseUrl(url, &scheme, &host, &path);
   const char* const headers[] = {
     "hello",    "bye",
     ":status",  status,
     "location", location,
     ":path",    path.c_str(),
     ":host",    host.c_str(),
     ":scheme",  scheme.c_str(),
     ":version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    headers,
                                    arraysize(headers),
                                    associated_stream_id);
 }
 
 SpdyFrame* ConstructSpdyPushHeaders(int stream_id,
                                     const char* const extra_headers[],
                                     int extra_header_count) {
   const char* const kStandardGetHeaders[] = {
-    ":status",
-    "200 OK",
-    ":version",
-    "HTTP/1.1"
+    ":status", "200 OK",
+    ":version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    HEADERS,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
 // Constructs a standard SPDY SYN_REPLY packet with the specified status code.
 // Returns a SpdyFrame.
-SpdyFrame* ConstructSpdySynReplyError(
-    const char* const status,
-    const char* const* const extra_headers,
-    int extra_header_count,
-    int stream_id) {
+SpdyFrame* ConstructSpdySynReplyError(const char* const status,
+                                      const char* const* const extra_headers,
+                                      int extra_header_count,
+                                      int stream_id) {
   const char* const kStandardGetHeaders[] = {
-    "hello",
-    "bye",
-    ":status",
-    status,
-    ":version",
-    "HTTP/1.1"
+    "hello", "bye",
+    ":status",  status,
+    ":version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_REPLY,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
 // Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGetSynReplyRedirect(int stream_id) {
   static const char* const kExtraHeaders[] = {
-    "location",
-    "http://www.foo.com/index.php",
+    "location", "http://www.foo.com/index.php",
   };
   return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
                                     arraysize(kExtraHeaders)/2, stream_id);
 }
 
 // Constructs a standard SPDY SYN_REPLY packet with an Internal Server
 // Error status code.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdySynReplyError(int stream_id) {
   return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
 }
 
 
 
 
 // Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyGetSynReply(const char* const extra_headers[],
-                                          int extra_header_count,
-                                          int stream_id) {
+                                    int extra_header_count,
+                                    int stream_id) {
   static const char* const kStandardGetHeaders[] = {
-    "hello",
-    "bye",
-    ":status",
-    "200",
-    ":version",
-    "HTTP/1.1"
+    "hello", "bye",
+    ":status", "200",
+    ":version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    stream_id,
                                    LOWEST,
                                    SYN_REPLY,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
 // Constructs a standard SPDY POST SYN packet.
 // |content_length| is the size of post data.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyPost(int64 content_length,
-                                   const char* const extra_headers[],
-                                   int extra_header_count) {
+                             const char* const extra_headers[],
+                             int extra_header_count) {
   std::string length_str = base::Int64ToString(content_length);
   const char* post_headers[] = {
-    ":method",
-    "POST",
-    ":path",
-    "/",
-    ":host",
-    "www.google.com",
-    ":scheme",
-    "http",
-    ":version",
-    "HTTP/1.1",
-    "content-length",
-    length_str.c_str()
+    ":method", "POST",
+    ":path", "/",
+    ":host", "www.google.com",
+    ":scheme", "http",
+    ":version", "HTTP/1.1",
+    "content-length",  length_str.c_str()
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    1,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    post_headers,
                                    arraysize(post_headers));
 }
 
 // Constructs a chunked transfer SPDY POST SYN packet.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructChunkedSpdyPost(const char* const extra_headers[],
-                                          int extra_header_count) {
+                                    int extra_header_count) {
   const char* post_headers[] = {
-    ":method",
-    "POST",
-    ":path",
-    "/",
-    ":host",
-    "www.google.com",
-    ":scheme",
-    "http",
-    ":version",
-    "HTTP/1.1"
+    ":method", "POST",
+    ":path", "/",
+    ":host", "www.google.com",
+    ":scheme", "http",
+    ":version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    1,
                                    LOWEST,
                                    SYN_STREAM,
                                    CONTROL_FLAG_NONE,
                                    post_headers,
                                    arraysize(post_headers));
 }
 
 // Constructs a standard SPDY SYN_REPLY packet to match the SPDY POST.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyPostSynReply(const char* const extra_headers[],
-                                           int extra_header_count) {
+                                     int extra_header_count) {
   static const char* const kStandardGetHeaders[] = {
-    "hello",
-    "bye",
-    ":status",
-    "200",
-    "url",
-    "/index.php",
-    ":version",
-    "HTTP/1.1"
+    "hello", "bye",
+    ":status", "200",
+    "url", "/index.php",
+    ":version", "HTTP/1.1"
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
                                    false,
                                    1,
                                    LOWEST,
                                    SYN_REPLY,
                                    CONTROL_FLAG_NONE,
                                    kStandardGetHeaders,
                                    arraysize(kStandardGetHeaders));
 }
 
 // Constructs a single SPDY data frame with the default contents.
 SpdyFrame* ConstructSpdyBodyFrame(int stream_id, bool fin) {
-  BufferedSpdyFramer framer(3);
+  BufferedSpdyFramer framer(3, false);
   return framer.CreateDataFrame(
       stream_id, kUploadData, kUploadDataSize,
       fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
 }
 
 // Constructs a single SPDY data frame with the given content.
 SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
-                                        uint32 len, bool fin) {
-  BufferedSpdyFramer framer(3);
+                                  uint32 len, bool fin) {
+  BufferedSpdyFramer framer(3, false);
   return framer.CreateDataFrame(
       stream_id, data, len, fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
 }
 
 // Wraps |frame| in the payload of a data frame in stream |stream_id|.
-SpdyFrame* ConstructWrappedSpdyFrame(
-    const scoped_ptr<SpdyFrame>& frame,
-    int stream_id) {
+SpdyFrame* ConstructWrappedSpdyFrame(const scoped_ptr<SpdyFrame>& frame,
+                                     int stream_id) {
   return ConstructSpdyBodyFrame(stream_id, frame->data(),
                                 frame->length() + SpdyFrame::kHeaderSize,
                                 false);
 }
 
 // Construct an expected SPDY reply string.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // |buffer| is the buffer we're filling in.
 // Returns the number of bytes written into |buffer|.
@@ skipping 124 matching lines @@
 
 SpdySessionDependencies::SpdySessionDependencies()
     : host_resolver(new MockCachingHostResolver),
       cert_verifier(new MockCertVerifier),
       proxy_service(ProxyService::CreateDirect()),
       ssl_config_service(new SSLConfigServiceDefaults),
       socket_factory(new MockClientSocketFactory),
       deterministic_socket_factory(new DeterministicMockClientSocketFactory),
       http_auth_handler_factory(
           HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
+      enable_ip_pooling(true),
+      enable_compression(false),
+      enable_ping(false),
+      initial_recv_window_size(kSpdyStreamInitialWindowSize),
+      time_func(&base::TimeTicks::Now),
       net_log(NULL) {
   // Note: The CancelledTransaction test does cleanup by running all
   // tasks in the message loop (RunAllPending).  Unfortunately, that
   // doesn't clean up tasks on the host resolver thread; and
   // TCPConnectJob is currently not cancellable.  Using synchronous
   // lookups allows the test to shutdown cleanly.  Until we have
   // cancellable TCPConnectJobs, use synchronous lookups.
   host_resolver->set_synchronous_mode(true);
 }
 
 SpdySessionDependencies::SpdySessionDependencies(ProxyService* proxy_service)
     : host_resolver(new MockHostResolver),
       cert_verifier(new MockCertVerifier),
       proxy_service(proxy_service),
       ssl_config_service(new SSLConfigServiceDefaults),
       socket_factory(new MockClientSocketFactory),
       deterministic_socket_factory(new DeterministicMockClientSocketFactory),
       http_auth_handler_factory(
           HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
+      enable_ip_pooling(true),
+      enable_compression(false),
+      enable_ping(false),
+      initial_recv_window_size(kSpdyStreamInitialWindowSize),
+      time_func(&base::TimeTicks::Now),
       net_log(NULL) {}
 
 SpdySessionDependencies::~SpdySessionDependencies() {}
 
 // static
 HttpNetworkSession* SpdySessionDependencies::SpdyCreateSession(
     SpdySessionDependencies* session_deps) {
   net::HttpNetworkSession::Params params = CreateSessionParams(session_deps);
   params.client_socket_factory = session_deps->socket_factory.get();
   HttpNetworkSession* http_session = new HttpNetworkSession(params);
@@ skipping 18 matching lines @@
 net::HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
     SpdySessionDependencies* session_deps) {
   net::HttpNetworkSession::Params params;
   params.host_resolver = session_deps->host_resolver.get();
   params.cert_verifier = session_deps->cert_verifier.get();
   params.proxy_service = session_deps->proxy_service.get();
   params.ssl_config_service = session_deps->ssl_config_service;
   params.http_auth_handler_factory =
       session_deps->http_auth_handler_factory.get();
   params.http_server_properties = &session_deps->http_server_properties;
+  params.enable_spdy_compression = session_deps->enable_compression;
+  params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping;
+  params.spdy_default_protocol = kProtoSPDY3;
+  params.spdy_initial_recv_window_size = session_deps->initial_recv_window_size;
+  params.time_func = session_deps->time_func;
   params.trusted_spdy_proxy = session_deps->trusted_spdy_proxy;
   params.net_log = session_deps->net_log;
   return params;
 }
 
 SpdyURLRequestContext::SpdyURLRequestContext()
     : ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this)) {
   storage_.set_host_resolver(scoped_ptr<HostResolver>(new MockHostResolver));
   storage_.set_cert_verifier(new MockCertVerifier);
   storage_.set_proxy_service(ProxyService::CreateDirect());
   storage_.set_ssl_config_service(new SSLConfigServiceDefaults);
   storage_.set_http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault(
       host_resolver()));
   storage_.set_http_server_properties(new HttpServerPropertiesImpl);
   net::HttpNetworkSession::Params params;
   params.client_socket_factory = &socket_factory_;
   params.host_resolver = host_resolver();
   params.cert_verifier = cert_verifier();
   params.proxy_service = proxy_service();
   params.ssl_config_service = ssl_config_service();
   params.http_auth_handler_factory = http_auth_handler_factory();
   params.network_delegate = network_delegate();
+  params.enable_spdy_compression = false;
+  params.enable_spdy_ping_based_connection_checking = false;
+  params.spdy_default_protocol = kProtoSPDY3;
   params.http_server_properties = http_server_properties();
   scoped_refptr<HttpNetworkSession> network_session(
       new HttpNetworkSession(params));
   SpdySessionPoolPeer pool_peer(network_session->spdy_session_pool());
   pool_peer.EnableSendingInitialSettings(false);
   storage_.set_http_transaction_factory(new HttpCache(
       network_session,
       HttpCache::DefaultBackend::InMemory(0)));
 }
 
@@ skipping 10 matching lines @@
     CONTROL_FLAG_FIN,       // Control Flags
     false,                        // Compressed
     INVALID,                // Status
     NULL,                         // Data
     0,                            // Length
     DATA_FLAG_NONE          // Data Flags
   };
   return kHeader;
 }
 
-SpdyTestStateHelper::SpdyTestStateHelper()
-    : ec_signature_creator_factory_(new MockECSignatureCreatorFactory()) {
-  // Use the mock signature creator.
-  crypto::ECSignatureCreator::SetFactoryForTesting(
-      ec_signature_creator_factory_.get());
-  // Pings can be non-deterministic, because they are sent via timer.
-  SpdySession::set_enable_ping_based_connection_checking(false);
-  // Avoid sending a non-default initial receive window size settings
-  // frame on every test.
-  SpdySession::set_default_initial_recv_window_size(
-      kSpdyStreamInitialWindowSize);
-  // Compression is per-session which makes it impossible to create
-  // SPDY frames with static methods.
-  BufferedSpdyFramer::set_enable_compression_default(false);
-}
-
-SpdyTestStateHelper::~SpdyTestStateHelper() {
-  SpdySession::ResetStaticSettingsToInit();
-  // TODO(rch): save/restore this value
-  BufferedSpdyFramer::set_enable_compression_default(true);
-  crypto::ECSignatureCreator::SetFactoryForTesting(NULL);
-}
-
 }  // namespace test_spdy3
 
 }  // namespace net