[SPDY] Move the rest of the spdy_test_util* functions to the SpdyTestUtil class

Add helper functions to abstract away the different header
keys between SPDY2 and SPDY3.

BUG=226192
R=rch@chromium.org

Review URL: https://codereview.chromium.org/16137006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@203518 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 499 insertions, 559 deletions

diff --git a/net/spdy/spdy_network_transaction_spdy2_unittest.cc b/net/spdy/spdy_network_transaction_spdy2_unittest.cc
index 62c0f95..4d93181 100644
--- a/net/spdy/spdy_network_transaction_spdy2_unittest.cc
+++ b/net/spdy/spdy_network_transaction_spdy2_unittest.cc
@@ -1679,7 +1679,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, Head) {
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, Post) {
   scoped_ptr<SpdyFrame> req(
-      ConstructSpdyPost(kRequestUrl, kUploadDataSize, NULL, 0));
+      ConstructSpdyPost(kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
@@ -1707,7 +1707,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, Post) {
 // Test that a POST with a file works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, FilePost) {
   scoped_ptr<SpdyFrame> req(
-      ConstructSpdyPost(kRequestUrl, kUploadDataSize, NULL, 0));
+      ConstructSpdyPost(kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
@@ -1735,7 +1735,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, FilePost) {
 // Test that a complex POST works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, ComplexPost) {
   scoped_ptr<SpdyFrame> req(
-      ConstructSpdyPost(kRequestUrl, kUploadDataSize, NULL, 0));
+      ConstructSpdyPost(kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
@@ -1864,7 +1864,8 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, NullPost) {
 
   // When request.upload_data_stream is NULL for post, content-length is
   // expected to be 0.
-  scoped_ptr<SpdyFrame> req(ConstructSpdyPost(kRequestUrl, 0, NULL, 0));
+  scoped_ptr<SpdyFrame> req(
+      ConstructSpdyPost(kRequestUrl, 1, 0, LOWEST, NULL, 0));
   // Set the FIN bit since there will be no body.
   test::SetFrameFlags(req.get(), CONTROL_FLAG_FIN, SPDY2);
   MockWrite writes[] = {
@@ -1905,7 +1906,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, EmptyPost) {
 
   const uint64 kContentLength = 0;
   scoped_ptr<SpdyFrame> req(
-      ConstructSpdyPost(kRequestUrl, kContentLength, NULL, 0));
+      ConstructSpdyPost(kRequestUrl, 1, kContentLength, LOWEST, NULL, 0));
   // Set the FIN bit since there will be no body.
   test::SetFrameFlags(req.get(), CONTROL_FLAG_FIN, SPDY2);
   MockWrite writes[] = {
@@ -1953,7 +1954,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, PostWithEarlySynReply) {
   };
 
   scoped_ptr<SpdyFrame> req(
-      ConstructSpdyPost(kRequestUrl, kUploadDataSize, NULL, 0));
+      ConstructSpdyPost(kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req, 0),
diff --git a/net/spdy/spdy_stream_spdy2_unittest.cc b/net/spdy/spdy_stream_spdy2_unittest.cc
index 835bc13..7ef8244 100644
--- a/net/spdy/spdy_stream_spdy2_unittest.cc
+++ b/net/spdy/spdy_stream_spdy2_unittest.cc
@@ -84,7 +84,7 @@ TEST_F(SpdyStreamSpdy2Test, SendDataAfterOpen) {
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
   scoped_ptr<SpdyFrame> req(
-      ConstructSpdyPost(kStreamUrl, kPostBodyLength, NULL, 0));
+      ConstructSpdyPost(kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> msg(
       ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
   MockWrite writes[] = {
@@ -196,7 +196,7 @@ TEST_F(SpdyStreamSpdy2Test, StreamError) {
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
   scoped_ptr<SpdyFrame> req(
-      ConstructSpdyPost(kStreamUrl, kPostBodyLength, NULL, 0));
+      ConstructSpdyPost(kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> msg(
       ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
   MockWrite writes[] = {
@@ -284,7 +284,7 @@ TEST_F(SpdyStreamSpdy2Test, SendLargeDataAfterOpenRequestResponse) {
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
   scoped_ptr<SpdyFrame> req(
-      ConstructSpdyPost(kStreamUrl, kPostBodyLength, NULL, 0));
+      ConstructSpdyPost(kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
   scoped_ptr<SpdyFrame> chunk(
       ConstructSpdyBodyFrame(
@@ -351,7 +351,7 @@ TEST_F(SpdyStreamSpdy2Test, SendLargeDataAfterOpenBidirectional) {
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
   scoped_ptr<SpdyFrame> req(
-      ConstructSpdyPost(kStreamUrl, kPostBodyLength, NULL, 0));
+      ConstructSpdyPost(kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
   scoped_ptr<SpdyFrame> chunk(
       ConstructSpdyBodyFrame(
diff --git a/net/spdy/spdy_test_util_common.cc b/net/spdy/spdy_test_util_common.cc
index 89d7796..bed9389 100644
--- a/net/spdy/spdy_test_util_common.cc
+++ b/net/spdy/spdy_test_util_common.cc
@@ -530,11 +530,11 @@ scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlock(
   std::string scheme, host, path;
   ParseUrl(url.data(), &scheme, &host, &path);
   const char* const headers[] = {
-    is_spdy2() ? "method"  : ":method",  "GET",
-    is_spdy2() ? "url"     : ":path",    path.c_str(),
-    is_spdy2() ? "host"    : ":host",    host.c_str(),
-    is_spdy2() ? "scheme"  : ":scheme",  scheme.c_str(),
-    is_spdy2() ? "version" : ":version", "HTTP/1.1"
+    GetMethodKey(),  "GET",
+    GetPathKey(),    path.c_str(),
+    GetHostKey(),    host.c_str(),
+    GetSchemeKey(),  scheme.c_str(),
+    GetVersionKey(), "HTTP/1.1"
   };
   scoped_ptr<SpdyHeaderBlock> header_block(new SpdyHeaderBlock());
   AppendToHeaderBlock(headers, arraysize(headers) / 2, header_block.get());
@@ -548,12 +548,12 @@ scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPostHeaderBlock(
   ParseUrl(url.data(), &scheme, &host, &path);
   std::string length_str = base::Int64ToString(content_length);
   const char* const headers[] = {
-    is_spdy2() ? "method"  : ":method",  "POST",
-    is_spdy2() ? "url"     : ":path",    path.c_str(),
-    is_spdy2() ? "host"    : ":host",    host.c_str(),
-    is_spdy2() ? "scheme"  : ":scheme",  scheme.c_str(),
-    is_spdy2() ? "version" : ":version", "HTTP/1.1",
-    "content-length",               length_str.c_str()
+    GetMethodKey(),   "POST",
+    GetPathKey(),     path.c_str(),
+    GetHostKey(),     host.c_str(),
+    GetSchemeKey(),   scheme.c_str(),
+    GetVersionKey(),  "HTTP/1.1",
+    "content-length", length_str.c_str()
   };
   scoped_ptr<SpdyHeaderBlock> header_block(new SpdyHeaderBlock());
   AppendToHeaderBlock(headers, arraysize(headers) / 2, header_block.get());
@@ -728,11 +728,11 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyGet(const char* const extra_headers[],
   const bool spdy2 = is_spdy2();
   const char* url = (spdy2 && !direct) ? "http://www.google.com/" : "/";
   const char* const kStandardGetHeaders[] = {
-    spdy2 ? "method"  : ":method",  "GET",
-    spdy2 ? "host"    : ":host",    "www.google.com",
-    spdy2 ? "scheme"  : ":scheme",  "http",
-    spdy2 ? "version" : ":version", "HTTP/1.1",
-    spdy2 ? "url"     : ":path",    url
+    GetMethodKey(),  "GET",
+    GetHostKey(),    "www.google.com",
+    GetSchemeKey(),  "http",
+    GetVersionKey(), "HTTP/1.1",
+    GetPathKey(),    url
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
@@ -750,12 +750,11 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyConnect(
     const char* const extra_headers[],
     int extra_header_count,
     int stream_id) const {
-  const bool spdy2 = is_spdy2();
   const char* const kConnectHeaders[] = {
-    spdy2 ? "method"  : ":method",  "CONNECT",
-    spdy2 ? "url"     : ":path",    "www.google.com:443",
-    spdy2 ? "host"    : ":host",    "www.google.com",
-    spdy2 ? "version" : ":version", "HTTP/1.1",
+    GetMethodKey(),  "CONNECT",
+    GetPathKey(),    "www.google.com:443",
+    GetHostKey(),    "www.google.com",
+    GetVersionKey(), "HTTP/1.1",
   };
   return ConstructSpdyControlFrame(extra_headers,
                                    extra_header_count,
@@ -769,8 +768,291 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyConnect(
                                    0);
 }
 
+SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
+                                           int extra_header_count,
+                                           int stream_id,
+                                           int associated_stream_id) {
+  const char* const kStandardGetHeaders[] = {
+    "hello",         "bye",
+    GetStatusKey(),  "200",
+    GetVersionKey(), "HTTP/1.1"
+  };
+  return ConstructSpdyControlFrame(extra_headers,
+                                   extra_header_count,
+                                   false,
+                                   stream_id,
+                                   LOWEST,
+                                   SYN_STREAM,
+                                   CONTROL_FLAG_NONE,
+                                   kStandardGetHeaders,
+                                   arraysize(kStandardGetHeaders),
+                                   associated_stream_id);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
+                                           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 kStandardGetHeaders[] = {
+    "hello",         "bye",
+    GetStatusKey(),  "200 OK",
+    GetVersionKey(), "HTTP/1.1",
+    GetPathKey(),    is_spdy2() ? url : path.c_str(),
+    GetHostKey(),    host.c_str(),
+    GetSchemeKey(),  scheme.c_str(),
+  };
+  return ConstructSpdyControlFrame(extra_headers,
+                                   extra_header_count,
+                                   false,
+                                   stream_id,
+                                   LOWEST,
+                                   SYN_STREAM,
+                                   CONTROL_FLAG_NONE,
+                                   kStandardGetHeaders,
+                                   arraysize(kStandardGetHeaders),
+                                   associated_stream_id);
+
+}
+SpdyFrame* SpdyTestUtil::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) {
+  std::string scheme, host, path;
+  ParseUrl(url, &scheme, &host, &path);
+  const char* const kStandardGetHeaders[] = {
+    "hello",         "bye",
+    GetStatusKey(),  status,
+    "location",      location,
+    GetPathKey(),    is_spdy2() ? url : path.c_str(),
+    GetHostKey(),    host.c_str(),
+    GetSchemeKey(),  scheme.c_str(),
+    GetVersionKey(), "HTTP/1.1"
+  };
+  return ConstructSpdyControlFrame(extra_headers,
+                                   extra_header_count,
+                                   false,
+                                   stream_id,
+                                   LOWEST,
+                                   SYN_STREAM,
+                                   CONTROL_FLAG_NONE,
+                                   kStandardGetHeaders,
+                                   arraysize(kStandardGetHeaders),
+                                   associated_stream_id);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructSpdyPushHeaders(
+    int stream_id,
+    const char* const extra_headers[],
+    int extra_header_count) {
+  const char* const kStandardGetHeaders[] = {
+    GetStatusKey(), "200 OK",
+    GetVersionKey(), "HTTP/1.1"
+  };
+  return ConstructSpdyControlFrame(extra_headers,
+                                   extra_header_count,
+                                   false,
+                                   stream_id,
+                                   LOWEST,
+                                   HEADERS,
+                                   CONTROL_FLAG_NONE,
+                                   kStandardGetHeaders,
+                                   arraysize(kStandardGetHeaders),
+                                   0);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructSpdySynReplyError(
+    const char* const status,
+    const char* const* const extra_headers,
+    int extra_header_count,
+    int stream_id) {
+  const char* const kStandardGetHeaders[] = {
+    "hello", "bye",
+    GetStatusKey(), status,
+    GetVersionKey(), "HTTP/1.1"
+  };
+  return ConstructSpdyControlFrame(extra_headers,
+                                   extra_header_count,
+                                   false,
+                                   stream_id,
+                                   LOWEST,
+                                   SYN_REPLY,
+                                   CONTROL_FLAG_NONE,
+                                   kStandardGetHeaders,
+                                   arraysize(kStandardGetHeaders),
+                                   0);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructSpdyGetSynReplyRedirect(int stream_id) {
+  static const char* const kExtraHeaders[] = {
+    "location", "http://www.foo.com/index.php",
+  };
+  return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
+                                    arraysize(kExtraHeaders)/2, stream_id);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructSpdySynReplyError(int stream_id) {
+  return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructSpdyGetSynReply(
+    const char* const extra_headers[],
+    int extra_header_count,
+    int stream_id) {
+  const char* const kStandardGetHeaders[] = {
+    "hello", "bye",
+    GetStatusKey(), "200",
+    GetVersionKey(), "HTTP/1.1"
+  };
+  return ConstructSpdyControlFrame(extra_headers,
+                                   extra_header_count,
+                                   false,
+                                   stream_id,
+                                   LOWEST,
+                                   SYN_REPLY,
+                                   CONTROL_FLAG_NONE,
+                                   kStandardGetHeaders,
+                                   arraysize(kStandardGetHeaders),
+                                   0);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructSpdyPost(const char* url,
+                                           SpdyStreamId stream_id,
+                                           int64 content_length,
+                                           RequestPriority priority,
+                                           const char* const extra_headers[],
+                                           int extra_header_count) {
+  const SpdyHeaderInfo kSynStartHeader = {
+    SYN_STREAM,
+    stream_id,
+    0,                      // Associated stream ID
+    ConvertRequestPriorityToSpdyPriority(priority, spdy_version_),
+    kSpdyCredentialSlotUnused,
+    CONTROL_FLAG_NONE,
+    false,                  // Compressed
+    RST_STREAM_INVALID,
+    NULL,                   // Data
+    0,                      // Length
+    DATA_FLAG_NONE
+  };
+  return ConstructSpdyFrame(
+      kSynStartHeader, ConstructPostHeaderBlock(url, content_length));
+}
+
+SpdyFrame* SpdyTestUtil::ConstructChunkedSpdyPost(
+    const char* const extra_headers[],
+    int extra_header_count) {
+  const char* post_headers[] = {
+    GetMethodKey(), "POST",
+    GetPathKey(), "/",
+    GetHostKey(), "www.google.com",
+    GetSchemeKey(), "http",
+    GetVersionKey(), "HTTP/1.1"
+  };
+  return ConstructSpdyControlFrame(extra_headers,
+                                   extra_header_count,
+                                   false,
+                                   1,
+                                   LOWEST,
+                                   SYN_STREAM,
+                                   CONTROL_FLAG_NONE,
+                                   post_headers,
+                                   arraysize(post_headers),
+                                   0);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructSpdyPostSynReply(
+    const char* const extra_headers[],
+    int extra_header_count) {
+  const char* const kStandardGetHeaders[] = {
+    "hello", "bye",
+    GetStatusKey(), "200",
+    GetPathKey(), "/index.php",
+    GetVersionKey(), "HTTP/1.1"
+  };
+  return ConstructSpdyControlFrame(extra_headers,
+                                   extra_header_count,
+                                   false,
+                                   1,
+                                   LOWEST,
+                                   SYN_REPLY,
+                                   CONTROL_FLAG_NONE,
+                                   kStandardGetHeaders,
+                                   arraysize(kStandardGetHeaders),
+                                   0);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id, bool fin) {
+  SpdyFramer framer(spdy_version_);
+  return framer.CreateDataFrame(
+      stream_id, kUploadData, kUploadDataSize,
+      fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
+                                                const char* data,
+                                                uint32 len,
+                                                bool fin) {
+  SpdyFramer framer(spdy_version_);
+  return framer.CreateDataFrame(
+      stream_id, data, len, fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
+}
+
+SpdyFrame* SpdyTestUtil::ConstructWrappedSpdyFrame(
+    const scoped_ptr<SpdyFrame>& frame,
+    int stream_id) {
+  return ConstructSpdyBodyFrame(stream_id, frame->data(),
+                                frame->size(), false);
+}
+
+const SpdyHeaderInfo SpdyTestUtil::MakeSpdyHeader(SpdyFrameType type) {
+  const SpdyHeaderInfo kHeader = {
+    type,
+    1,                            // Stream ID
+    0,                            // Associated stream ID
+    ConvertRequestPriorityToSpdyPriority(LOWEST, spdy_version_),
+    kSpdyCredentialSlotUnused,
+    CONTROL_FLAG_FIN,             // Control Flags
+    false,                        // Compressed
+    RST_STREAM_INVALID,
+    NULL,                         // Data
+    0,                            // Length
+    DATA_FLAG_NONE
+  };
+  return kHeader;
+}
+
 scoped_ptr<SpdyFramer> SpdyTestUtil::CreateFramer() const {
   return scoped_ptr<SpdyFramer>(new SpdyFramer(spdy_version_));
 }
 
+const char* SpdyTestUtil::GetMethodKey() const {
+  return is_spdy2() ? "method" : ":method";
+}
+
+const char* SpdyTestUtil::GetStatusKey() const {
+  return is_spdy2() ? "status" : ":status";
+}
+
+const char* SpdyTestUtil::GetHostKey() const {
+  return is_spdy2() ? "host" : ":host";
+}
+
+const char* SpdyTestUtil::GetSchemeKey() const {
+  return is_spdy2() ? "scheme" : ":scheme";
+}
+
+const char* SpdyTestUtil::GetVersionKey() const {
+  return is_spdy2() ? "version" : ":version";
+}
+
+const char* SpdyTestUtil::GetPathKey() const {
+  return is_spdy2() ? "url" : ":path";
+}
+
 }  // namespace net
diff --git a/net/spdy/spdy_test_util_common.h b/net/spdy/spdy_test_util_common.h
index 7100a82..1ba1d2d 100644
--- a/net/spdy/spdy_test_util_common.h
+++ b/net/spdy/spdy_test_util_common.h
@@ -353,12 +353,109 @@ class SpdyTestUtil {
                                   int extra_header_count,
                                   int stream_id) const;
 
+  // Constructs a standard SPDY push SYN frame.
+  // |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);
+  SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
+                               int extra_header_count,
+                               int stream_id,
+                               int associated_stream_id,
+                               const char* url);
+  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);
+
+  SpdyFrame* ConstructSpdyPushHeaders(int stream_id,
+                                      const char* const extra_headers[],
+                                      int extra_header_count);
+
+  // Constructs a standard SPDY SYN_REPLY frame 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);
+
+  // Constructs a standard SPDY SYN_REPLY frame 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);
+
+  // Constructs a standard SPDY SYN_REPLY frame with an Internal Server
+  // Error status code.
+  // Returns a SpdyFrame.
+  SpdyFrame* ConstructSpdySynReplyError(int stream_id);
+
+  // Constructs a standard SPDY SYN_REPLY frame 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);
+
+  // Constructs a standard SPDY POST SYN frame.
+  // |extra_headers| are the extra header-value pairs, which typically
+  // will vary the most between calls.
+  // Returns a SpdyFrame.
+  SpdyFrame* ConstructSpdyPost(const char* url,
+                               SpdyStreamId stream_id,
+                               int64 content_length,
+                               RequestPriority priority,
+                               const char* const extra_headers[],
+                               int extra_header_count);
+
+  // Constructs a chunked transfer SPDY POST SYN frame.
+  // |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);
+
+  // Constructs a standard SPDY SYN_REPLY frame 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);
+
+  // Constructs a single SPDY data frame with the contents "hello!"
+  SpdyFrame* ConstructSpdyBodyFrame(int stream_id,
+                                    bool fin);
+
+  // Constructs a single SPDY data frame with the given content.
+  SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
+                                    uint32 len, bool fin);
+
+  // Wraps |frame| in the payload of a data frame in stream |stream_id|.
+  SpdyFrame* ConstructWrappedSpdyFrame(const scoped_ptr<SpdyFrame>& frame,
+                                       int stream_id);
+
+  const SpdyHeaderInfo MakeSpdyHeader(SpdyFrameType type);
+
   NextProto protocol() const { return protocol_; }
   SpdyMajorVersion spdy_version() const { return spdy_version_; }
   bool is_spdy2() const { return protocol_ < kProtoSPDY3; }
   scoped_ptr<SpdyFramer> CreateFramer() const;
 
  private:
+  const char* GetMethodKey() const;
+  const char* GetStatusKey() const;
+  const char* GetHostKey() const;
+  const char* GetSchemeKey() const;
+  const char* GetVersionKey() const;
+  const char* GetPathKey() const;
+
   const NextProto protocol_;
   const SpdyMajorVersion spdy_version_;
 };
diff --git a/net/spdy/spdy_test_util_spdy2.cc b/net/spdy/spdy_test_util_spdy2.cc
index eb49001..1a12a3d 100644
--- a/net/spdy/spdy_test_util_spdy2.cc
+++ b/net/spdy/spdy_test_util_spdy2.cc
@@ -21,71 +21,13 @@
 namespace net {
 namespace test_spdy2 {
 
-namespace {
-
-scoped_ptr<SpdyHeaderBlock> ConstructGetHeaderBlock(base::StringPiece url) {
-  SpdyTestUtil util(kProtoSPDY2);
-  return util.ConstructGetHeaderBlock(url);
-}
-
-scoped_ptr<SpdyHeaderBlock> ConstructPostHeaderBlock(base::StringPiece url,
-                                                     int64 content_length) {
-  SpdyTestUtil util(kProtoSPDY2);
-  return util.ConstructPostHeaderBlock(url, content_length);
-}
-
-// Construct a SPDY frame.
-SpdyFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
-                              scoped_ptr<SpdyHeaderBlock> headers) {
-  SpdyTestUtil util(kProtoSPDY2);
-  return util.ConstructSpdyFrame(header_info, headers.Pass());
-}
-
-// Construct a generic SpdyControlFrame.
-SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
-                                     int extra_header_count,
-                                     bool compressed,
-                                     SpdyStreamId stream_id,
-                                     RequestPriority request_priority,
-                                     SpdyFrameType type,
-                                     SpdyControlFlags flags,
-                                     const char* const* kHeaders,
-                                     int kHeadersSize,
-                                     SpdyStreamId associated_stream_id) {
-  SpdyTestUtil util(kProtoSPDY2);
-  return util.ConstructSpdyControlFrame(extra_headers,
-                                        extra_header_count,
-                                        compressed,
-                                        stream_id,
-                                        request_priority,
-                                        type,
-                                        flags,
-                                        kHeaders,
-                                        kHeadersSize,
-                                        associated_stream_id);
-}
-
-}  // namespace
-
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              int extra_header_count,
                              int stream_id,
                              int associated_stream_id) {
-  const char* const kStandardGetHeaders[] = {
-    "hello", "bye",
-    "status", "200",
-    "version", "HTTP/1.1"
-  };
-  return ConstructSpdyControlFrame(extra_headers,
-                                   extra_header_count,
-                                   false,
-                                   stream_id,
-                                   LOWEST,
-                                   SYN_STREAM,
-                                   CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
-                                   associated_stream_id);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdyPush(extra_headers, extra_header_count,
+                                stream_id, associated_stream_id);
 }
 
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
@@ -93,23 +35,9 @@ SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              int stream_id,
                              int associated_stream_id,
                              const char* url) {
-  const char* const kStandardGetHeaders[] = {
-    "hello", "bye",
-    "status", "200 OK",
-    "url", url,
-    "version", "HTTP/1.1"
-  };
-  return ConstructSpdyControlFrame(extra_headers,
-                                   extra_header_count,
-                                   false,
-                                   stream_id,
-                                   LOWEST,
-                                   SYN_STREAM,
-                                   CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
-                                   associated_stream_id);
-
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdyPush(extra_headers, extra_header_count,
+                                stream_id, associated_stream_id, url);
 }
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              int extra_header_count,
@@ -118,213 +46,90 @@ SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              const char* url,
                              const char* status,
                              const char* location) {
-  const char* const kStandardGetHeaders[] = {
-    "hello", "bye",
-    "status",  status,
-    "location", location,
-    "url", url,
-    "version", "HTTP/1.1"
-  };
-  return ConstructSpdyControlFrame(extra_headers,
-                                   extra_header_count,
-                                   false,
-                                   stream_id,
-                                   LOWEST,
-                                   SYN_STREAM,
-                                   CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
-                                   associated_stream_id);
-}
-
-SpdyFrame* ConstructSpdyPush(int stream_id,
-                             int associated_stream_id,
-                             const char* url) {
-  const char* const kStandardGetHeaders[] = {
-    "url", url
-  };
-  return ConstructSpdyControlFrame(0,
-                                   0,
-                                   false,
-                                   stream_id,
-                                   LOWEST,
-                                   SYN_STREAM,
-                                   CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
-                                   associated_stream_id);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdyPush(extra_headers, extra_header_count,
+                                stream_id, associated_stream_id, url,
+                                status, location);
 }
 
 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"
-  };
-  return ConstructSpdyControlFrame(extra_headers,
-                                   extra_header_count,
-                                   false,
-                                   stream_id,
-                                   LOWEST,
-                                   HEADERS,
-                                   CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
-                                   0);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdyPushHeaders(stream_id, extra_headers,
+                                       extra_header_count);
 }
 
 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"
-  };
-  return ConstructSpdyControlFrame(extra_headers,
-                                   extra_header_count,
-                                   false,
-                                   stream_id,
-                                   LOWEST,
-                                   SYN_REPLY,
-                                   CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
-                                   0);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdySynReplyError(status, extra_headers,
+                                         extra_header_count, stream_id);
 }
 
 SpdyFrame* ConstructSpdyGetSynReplyRedirect(int stream_id) {
-  static const char* const kExtraHeaders[] = {
-    "location", "http://www.foo.com/index.php",
-  };
-  return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
-                                    arraysize(kExtraHeaders)/2, stream_id);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdyGetSynReplyRedirect(stream_id);
 }
 
 SpdyFrame* ConstructSpdySynReplyError(int stream_id) {
-  return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdySynReplyError(stream_id);
 }
 
 SpdyFrame* ConstructSpdyGetSynReply(const char* const extra_headers[],
                                     int extra_header_count,
                                     int stream_id) {
-  static const char* const kStandardGetHeaders[] = {
-    "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),
-                                   0);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdyGetSynReply(extra_headers, extra_header_count,
+                                       stream_id);
 }
 
 SpdyFrame* ConstructSpdyPost(const char* url,
+                             SpdyStreamId stream_id,
                              int64 content_length,
+                             RequestPriority priority,
                              const char* const extra_headers[],
                              int extra_header_count) {
-  const SpdyHeaderInfo kSynStartHeader = {
-    SYN_STREAM,             // Kind = Syn
-    1,                      // Stream ID
-    0,                      // Associated stream ID
-    ConvertRequestPriorityToSpdyPriority(LOWEST, 2),
-                            // Priority
-    kSpdyCredentialSlotUnused,
-    CONTROL_FLAG_NONE,      // Control Flags
-    false,                  // Compressed
-    RST_STREAM_INVALID,     // Status
-    NULL,                   // Data
-    0,                      // Length
-    DATA_FLAG_NONE          // Data Flags
-  };
-  return ConstructSpdyFrame(
-      kSynStartHeader, ConstructPostHeaderBlock(url, content_length));
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdyPost(url, stream_id, content_length,
+                                priority, extra_headers, extra_header_count);
 }
 
 SpdyFrame* ConstructChunkedSpdyPost(const char* const extra_headers[],
                                     int extra_header_count) {
-  const char* post_headers[] = {
-    "method", "POST",
-    "url", "/",
-    "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),
-                                   0);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructChunkedSpdyPost(extra_headers, extra_header_count);
 }
 
 SpdyFrame* ConstructSpdyPostSynReply(const char* const extra_headers[],
                                      int extra_header_count) {
-  static const char* const kStandardGetHeaders[] = {
-    "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),
-                                   0);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdyPostSynReply(extra_headers, extra_header_count);
 }
 
 SpdyFrame* ConstructSpdyBodyFrame(int stream_id, bool fin) {
-  SpdyFramer framer(SPDY2);
-  return framer.CreateDataFrame(
-      stream_id, kUploadData, kUploadDataSize,
-      fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdyBodyFrame(stream_id, fin);
 }
 
 SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
                                   uint32 len, bool fin) {
-  SpdyFramer framer(SPDY2);
-  return framer.CreateDataFrame(
-      stream_id, data, len, fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructSpdyBodyFrame(stream_id, data, len, fin);
 }
 
 SpdyFrame* ConstructWrappedSpdyFrame(const scoped_ptr<SpdyFrame>& frame,
                                      int stream_id) {
-  return ConstructSpdyBodyFrame(stream_id, frame->data(),
-                                frame->size(), false);
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.ConstructWrappedSpdyFrame(frame, stream_id);
 }
 
 const SpdyHeaderInfo MakeSpdyHeader(SpdyFrameType type) {
-  const SpdyHeaderInfo kHeader = {
-    type,                         // Kind = Syn
-    1,                            // Stream ID
-    0,                            // Associated stream ID
-    ConvertRequestPriorityToSpdyPriority(LOWEST, 2),  // Priority
-    kSpdyCredentialSlotUnused,
-    CONTROL_FLAG_FIN,       // Control Flags
-    false,                        // Compressed
-    RST_STREAM_INVALID,           // Status
-    NULL,                         // Data
-    0,                            // Length
-    DATA_FLAG_NONE          // Data Flags
-  };
-  return kHeader;
+  SpdyTestUtil util(kProtoSPDY2);
+  return util.MakeSpdyHeader(type);
 }
 
 }  // namespace test_spdy2
diff --git a/net/spdy/spdy_test_util_spdy2.h b/net/spdy/spdy_test_util_spdy2.h
index 10d1ee0..900cf06 100644
--- a/net/spdy/spdy_test_util_spdy2.h
+++ b/net/spdy/spdy_test_util_spdy2.h
@@ -44,9 +44,6 @@ SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              const char* url,
                              const char* status,
                              const char* location);
-SpdyFrame* ConstructSpdyPush(int stream_id,
-                             int associated_stream_id,
-                             const char* url);
 
 SpdyFrame* ConstructSpdyPushHeaders(int stream_id,
                                     const char* const extra_headers[],
@@ -83,7 +80,9 @@ SpdyFrame* ConstructSpdySynReplyError(const char* const status,
 // will vary the most between calls.
 // Returns a SpdyFrame.
 SpdyFrame* ConstructSpdyPost(const char* url,
+                             SpdyStreamId stream_id,
                              int64 content_length,
+                             RequestPriority priority,
                              const char* const extra_headers[],
                              int extra_header_count);
 
diff --git a/net/spdy/spdy_test_util_spdy3.cc b/net/spdy/spdy_test_util_spdy3.cc
index 89223d5..ecdf963 100644
--- a/net/spdy/spdy_test_util_spdy3.cc
+++ b/net/spdy/spdy_test_util_spdy3.cc
@@ -20,121 +20,13 @@ 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());
-  }
-}
-
-scoped_ptr<SpdyHeaderBlock> ConstructGetHeaderBlock(base::StringPiece url) {
-  SpdyTestUtil util(kProtoSPDY3);
-  return util.ConstructGetHeaderBlock(url);
-}
-
-scoped_ptr<SpdyHeaderBlock> ConstructPostHeaderBlock(base::StringPiece url,
-                                                     int64 content_length) {
-  SpdyTestUtil util(kProtoSPDY3);
-  return util.ConstructPostHeaderBlock(url, content_length);
-}
-
-// Construct a SPDY frame. |spdy_version| must be SPDY3 or SPDY4.
-SpdyFrame* ConstructSpdyFrameWithVersion(SpdyMajorVersion spdy_version,
-                                         const SpdyHeaderInfo& header_info,
-                                         scoped_ptr<SpdyHeaderBlock> headers) {
-  DCHECK(spdy_version == SPDY3 || spdy_version == SPDY4);
-  SpdyTestUtil util(NextProtoFromSpdyVersion(spdy_version));
-  return util.ConstructSpdyFrame(header_info, headers.Pass());
-}
-
-// Construct a SPDY frame.
-SpdyFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
-                              scoped_ptr<SpdyHeaderBlock> headers) {
-  SpdyTestUtil util(kProtoSPDY3);
-  return util.ConstructSpdyFrame(header_info, headers.Pass());
-}
-
-// Construct a SPDY control frame. |spdy_version| must be
-// kSpdyVersion3 or kSpdyVersion4.
-SpdyFrame* ConstructSpdyControlFrameWithVersion(
-    SpdyMajorVersion spdy_verson,
-    const char* const extra_headers[],
-    int extra_header_count,
-    bool compressed,
-    SpdyStreamId stream_id,
-    RequestPriority request_priority,
-    SpdyFrameType type,
-    SpdyControlFlags flags,
-    const char* const* kHeaders,
-    int kHeadersSize,
-    SpdyStreamId associated_stream_id) {
-  SpdyTestUtil util(NextProtoFromSpdyVersion(spdy_verson));
-  return util.ConstructSpdyControlFrame(extra_headers,
-                                        extra_header_count,
-                                        compressed,
-                                        stream_id,
-                                        request_priority,
-                                        type,
-                                        flags,
-                                        kHeaders,
-                                        kHeadersSize,
-                                        associated_stream_id);
-}
-
-// Construct a generic SPDY control frame with an associated stream ID.
-SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
-                                     int extra_header_count,
-                                     bool compressed,
-                                     SpdyStreamId stream_id,
-                                     RequestPriority request_priority,
-                                     SpdyFrameType type,
-                                     SpdyControlFlags flags,
-                                     const char* const* kHeaders,
-                                     int kHeadersSize,
-                                     SpdyStreamId associated_stream_id) {
-  SpdyTestUtil util(kProtoSPDY3);
-  return util.ConstructSpdyControlFrame(extra_headers,
-                                        extra_header_count,
-                                        compressed,
-                                        stream_id,
-                                        request_priority,
-                                        type,
-                                        flags,
-                                        kHeaders,
-                                        kHeadersSize,
-                                        associated_stream_id);
-}
-
-}  // namespace
-
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              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);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdyPush(extra_headers, extra_header_count,
+                                stream_id, associated_stream_id);
 }
 
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
@@ -142,27 +34,9 @@ SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              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);
-
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdyPush(extra_headers, extra_header_count,
+                                stream_id, associated_stream_id, url);
 }
 SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              int extra_header_count,
@@ -171,99 +45,45 @@ SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              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);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdyPush(extra_headers, extra_header_count,
+                                stream_id, associated_stream_id, url,
+                                status, location);
 }
 
 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"
-  };
-  return ConstructSpdyControlFrame(extra_headers,
-                                   extra_header_count,
-                                   false,
-                                   stream_id,
-                                   LOWEST,
-                                   HEADERS,
-                                   CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
-                                   0);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdyPushHeaders(stream_id, extra_headers,
+                                       extra_header_count);
 }
 
 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"
-  };
-  return ConstructSpdyControlFrame(extra_headers,
-                                   extra_header_count,
-                                   false,
-                                   stream_id,
-                                   LOWEST,
-                                   SYN_REPLY,
-                                   CONTROL_FLAG_NONE,
-                                   kStandardGetHeaders,
-                                   arraysize(kStandardGetHeaders),
-                                   0);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdySynReplyError(status, extra_headers,
+                                         extra_header_count, stream_id);
 }
 
 SpdyFrame* ConstructSpdyGetSynReplyRedirect(int stream_id) {
-  static const char* const kExtraHeaders[] = {
-    "location", "http://www.foo.com/index.php",
-  };
-  return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
-                                    arraysize(kExtraHeaders)/2, stream_id);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdyGetSynReplyRedirect(stream_id);
 }
 
 SpdyFrame* ConstructSpdySynReplyError(int stream_id) {
-  return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdySynReplyError(stream_id);
 }
 
 SpdyFrame* ConstructSpdyGetSynReply(const char* const extra_headers[],
                                     int extra_header_count,
                                     int stream_id) {
-  static const char* const kStandardGetHeaders[] = {
-    "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),
-                                   0);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdyGetSynReply(extra_headers, extra_header_count,
+                                       stream_id);
 }
 
 SpdyFrame* ConstructSpdyPost(const char* url,
@@ -272,125 +92,64 @@ SpdyFrame* ConstructSpdyPost(const char* url,
                              RequestPriority priority,
                              const char* const extra_headers[],
                              int extra_header_count) {
-  const SpdyHeaderInfo kSynStartHeader = {
-    SYN_STREAM,                   // Kind = Syn
-    stream_id,                    // Stream ID
-    0,                            // Associated stream ID
-    ConvertRequestPriorityToSpdyPriority(priority, SPDY3),
-                                  // Priority
-    0,                            // Credential Slot
-    CONTROL_FLAG_NONE,            // Control Flags
-    false,                        // Compressed
-    RST_STREAM_INVALID,           // Status
-    NULL,                         // Data
-    0,                            // Length
-    DATA_FLAG_NONE                // Data Flags
-  };
-  return ConstructSpdyFrame(
-      kSynStartHeader, ConstructPostHeaderBlock(url, content_length));
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdyPost(url, stream_id, content_length,
+                                priority, extra_headers, extra_header_count);
 }
 
 SpdyFrame* ConstructChunkedSpdyPostWithVersion(
     SpdyMajorVersion spdy_version,
     const char* const extra_headers[],
     int extra_header_count) {
-  const char* post_headers[] = {
-    ":method", "POST",
-    ":path", "/",
-    ":host", "www.google.com",
-    ":scheme", "http",
-    ":version", "HTTP/1.1"
-  };
-  return ConstructSpdyControlFrameWithVersion(spdy_version,
-                                              extra_headers,
-                                              extra_header_count,
-                                              false,
-                                              1,
-                                              LOWEST,
-                                              SYN_STREAM,
-                                              CONTROL_FLAG_NONE,
-                                              post_headers,
-                                              arraysize(post_headers),
-                                              0);
+  SpdyTestUtil util(NextProtoFromSpdyVersion(spdy_version));
+  return util.ConstructChunkedSpdyPost(extra_headers, extra_header_count);
 }
 
 SpdyFrame* ConstructChunkedSpdyPost(const char* const extra_headers[],
                                     int extra_header_count) {
-  return ConstructChunkedSpdyPostWithVersion(SPDY3,
-                                             extra_headers,
-                                             extra_header_count);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructChunkedSpdyPost(extra_headers, extra_header_count);
 }
 
 SpdyFrame* ConstructSpdyPostSynReplyWithVersion(
     SpdyMajorVersion spdy_version,
     const char* const extra_headers[],
     int extra_header_count) {
-  static const char* const kStandardGetHeaders[] = {
-    "hello", "bye",
-    ":status", "200",
-    "url", "/index.php",
-    ":version", "HTTP/1.1"
-  };
-  return ConstructSpdyControlFrameWithVersion(
-      spdy_version,
-      extra_headers,
-      extra_header_count,
-      false,
-      1,
-      LOWEST,
-      SYN_REPLY,
-      CONTROL_FLAG_NONE,
-      kStandardGetHeaders,
-      arraysize(kStandardGetHeaders),
-      0);
+  SpdyTestUtil util(NextProtoFromSpdyVersion(spdy_version));
+  return util.ConstructSpdyPostSynReply(extra_headers, extra_header_count);
 }
 
 SpdyFrame* ConstructSpdyPostSynReply(const char* const extra_headers[],
                                      int extra_header_count) {
-  return ConstructSpdyPostSynReplyWithVersion(SPDY3,
-                                              extra_headers,
-                                              extra_header_count);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdyPostSynReply(extra_headers, extra_header_count);
 }
 
 // Constructs a single SPDY data frame with the default contents.
 SpdyFrame* ConstructSpdyBodyFrame(int stream_id, bool fin) {
-  BufferedSpdyFramer framer(SPDY3, false);
-  return framer.CreateDataFrame(
-      stream_id, kUploadData, kUploadDataSize,
-      fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdyBodyFrame(stream_id, fin);
 }
 
 // Constructs a single SPDY data frame with the given content.
-SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
-                                  uint32 len, bool fin) {
-  BufferedSpdyFramer framer(SPDY3, false);
-  return framer.CreateDataFrame(
-      stream_id, data, len, fin ? DATA_FLAG_FIN : DATA_FLAG_NONE);
+SpdyFrame* ConstructSpdyBodyFrame(int stream_id,
+                                  const char* data,
+                                  uint32 len,
+                                  bool fin) {
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructSpdyBodyFrame(stream_id, data, len, fin);
 }
 
 // Wraps |frame| in the payload of a data frame in stream |stream_id|.
 SpdyFrame* ConstructWrappedSpdyFrame(const scoped_ptr<SpdyFrame>& frame,
                                      int stream_id) {
-  return ConstructSpdyBodyFrame(stream_id, frame->data(),
-                                frame->size(),
-                                false);
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.ConstructWrappedSpdyFrame(frame, stream_id);
 }
 
 const SpdyHeaderInfo MakeSpdyHeader(SpdyFrameType type) {
-  const SpdyHeaderInfo kHeader = {
-    type,                         // Kind = Syn
-    1,                            // Stream ID
-    0,                            // Associated stream ID
-    ConvertRequestPriorityToSpdyPriority(LOWEST, 3),  // Priority
-    0,                            // Credential Slot
-    CONTROL_FLAG_FIN,       // Control Flags
-    false,                        // Compressed
-    RST_STREAM_INVALID,           // Status
-    NULL,                         // Data
-    0,                            // Length
-    DATA_FLAG_NONE          // Data Flags
-  };
-  return kHeader;
+  SpdyTestUtil util(kProtoSPDY3);
+  return util.MakeSpdyHeader(type);
 }
 
 }  // namespace test_spdy3
diff --git a/net/spdy/spdy_test_util_spdy3.h b/net/spdy/spdy_test_util_spdy3.h
index 260608f..466b1af 100644
--- a/net/spdy/spdy_test_util_spdy3.h
+++ b/net/spdy/spdy_test_util_spdy3.h
@@ -48,9 +48,6 @@ SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
                              const char* url,
                              const char* status,
                              const char* location);
-SpdyFrame* ConstructSpdyPush(int stream_id,
-                             int associated_stream_id,
-                             const char* url);
 
 SpdyFrame* ConstructSpdyPushHeaders(int stream_id,
                                     const char* const extra_headers[],