[SPDY] Enable tests for SPDY/3.1 and SPDY/4

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
@@ skipping 65 matching lines @@
     case kProtoHTTP11:
     case kProtoSPDY1:
     case kProtoSPDY21:
       break;
   }
 
   NOTREACHED();
   return HttpResponseInfo::CONNECTION_INFO_SPDY2;
 }
 
-AlternateProtocol NextProtoToAlternateProtocol(NextProto next_proto) {
-  switch (next_proto) {
-    case kProtoSPDY2:
-      return NPN_SPDY_2;
-    case kProtoSPDY3:
-      return NPN_SPDY_3;
-    case kProtoSPDY31:
-      return NPN_SPDY_3_1;
-    case kProtoSPDY4a2:
-      return NPN_SPDY_4A2;
-
-    case kProtoUnknown:
-    case kProtoHTTP11:
-    case kProtoSPDY1:
-    case kProtoSPDY21:
-      break;
-  }
-
-  NOTREACHED();
-  return NPN_SPDY_2;
-}
-
 SpdySessionDependencies* CreateSpdySessionDependencies(
     SpdyNetworkTransactionTestParams test_params) {
   return new SpdySessionDependencies(test_params.protocol);
 }
 
 SpdySessionDependencies* CreateSpdySessionDependencies(
     SpdyNetworkTransactionTestParams test_params,
     ProxyService* proxy_service) {
   return new SpdySessionDependencies(test_params.protocol, proxy_service);
 }
@@ skipping 83 matching lines @@
     void RunPreTestSetup() {
       if (!session_deps_.get())
         session_deps_.reset(CreateSpdySessionDependencies(test_params_));
       if (!session_.get())
         session_ = SpdySessionDependencies::SpdyCreateSession(
             session_deps_.get());
       HttpStreamFactory::set_use_alternate_protocols(false);
       HttpStreamFactory::set_force_spdy_over_ssl(false);
       HttpStreamFactory::set_force_spdy_always(false);
 
-      std::vector<std::string> next_protos;
-      next_protos.push_back("http/1.1");
-      next_protos.push_back("spdy/2");
+      std::vector<std::string> next_protos = SpdyNextProtos();
 
       switch (test_params_.ssl_type) {
         case SPDYNPN:
           session_->http_server_properties()->SetAlternateProtocol(
               HostPortPair("www.google.com", 80), 443,
-              NextProtoToAlternateProtocol(test_params_.protocol));
+              AlternateProtocolFromNextProto(test_params_.protocol));
           HttpStreamFactory::set_use_alternate_protocols(true);
           HttpStreamFactory::SetNextProtos(next_protos);
           break;
         case SPDYNOSSL:
           HttpStreamFactory::set_force_spdy_over_ssl(false);
           HttpStreamFactory::set_force_spdy_always(true);
           break;
         case SPDYSSL:
           HttpStreamFactory::set_force_spdy_over_ssl(true);
           HttpStreamFactory::set_force_spdy_always(true);
@@ skipping 360 matching lines @@
     EXPECT_TRUE(pool->HasSession(key));
     scoped_refptr<SpdySession> spdy_session(pool->Get(key, log));
     ASSERT_TRUE(spdy_session.get() != NULL);
     EXPECT_EQ(0u, spdy_session->num_active_streams());
     EXPECT_EQ(0u, spdy_session->num_unclaimed_pushed_streams());
   }
 
   void RunServerPushTest(OrderedSocketData* data,
                          HttpResponseInfo* response,
                          HttpResponseInfo* push_response,
-                         std::string& expected) {
+                         const std::string& expected) {
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunPreTestSetup();
     helper.AddData(data);
 
     HttpNetworkTransaction* trans = helper.trans();
 
     // Start the transaction with basic parameters.
     TestCompletionCallback callback;
     int rv = trans->Start(
@@ skipping 97 matching lines @@
 // Verify HttpNetworkTransaction constructor.
 TEST_P(SpdyNetworkTransactionTest, Constructor) {
   scoped_ptr<SpdySessionDependencies> session_deps(
       CreateSpdySessionDependencies(GetParam()));
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(session_deps.get()));
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 }
 
-// TODO(akalin): Don't early-exit in the tests below for values >
-// kProtoSPDY3.
-
 TEST_P(SpdyNetworkTransactionTest, Get) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(1, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 TEST_P(SpdyNetworkTransactionTest, GetAtEachPriority) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   for (RequestPriority p = MINIMUM_PRIORITY; p < NUM_PRIORITIES;
        p = RequestPriority(p + 1)) {
     // Construct the request.
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, p, true));
     MockWrite writes[] = { CreateMockWrite(*req) };
 
     SpdyPriority spdy_prio = 0;
     EXPECT_TRUE(GetSpdyPriority(spdy_util_.spdy_version(), *req, &spdy_prio));
     // this repeats the RequestPriority-->SpdyPriority mapping from
@@ skipping 65 matching lines @@
 // streams work properly.
 
 // This can't use the TransactionHelper method, since it only
 // handles a single transaction, and finishes them as soon
 // as it launches them.
 
 // TODO(gavinp): create a working generalized TransactionHelper that
 // can allow multiple streams in flight.
 
 TEST_P(SpdyNetworkTransactionTest, ThreeGets) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
@@ skipping 76 matching lines @@
   out.rv = ReadTransaction(trans1.get(), &out.response_data);
   helper.VerifyDataConsumed();
   EXPECT_EQ(OK, out.rv);
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 }
 
 TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBinding) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
@@ skipping 67 matching lines @@
   out.response_info = *response2;
   out.rv = ReadTransaction(trans2.get(), &out.response_data);
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
 
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBindingFromPreconnect) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
@@ skipping 86 matching lines @@
 
   helper.VerifyDataConsumed();
 }
 
 // Similar to ThreeGets above, however this test adds a SETTINGS
 // frame.  The SETTINGS frame is read during the IO loop waiting on
 // the first transaction completion, and sets a maximum concurrent
 // stream limit of 1.  This means that our IO loop exists after the
 // second transaction completes, so we can assert on read_index().
 TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrent) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
@@ skipping 113 matching lines @@
   }
   EXPECT_EQ(OK, out.rv);
 }
 
 // Similar to ThreeGetsWithMaxConcurrent above, however this test adds
 // a fourth transaction.  The third and fourth transactions have
 // different data ("hello!" vs "hello!hello!") and because of the
 // user specified priority, we expect to see them inverted in
 // the response from the server.
 TEST_P(SpdyNetworkTransactionTest, FourGetsWithMaxConcurrentPriority) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
@@ skipping 133 matching lines @@
   EXPECT_EQ("hello!", out.response_data);
   helper.VerifyDataConsumed();
   EXPECT_EQ(OK, out.rv);
 }
 
 // Similar to ThreeGetsMaxConcurrrent above, however, this test
 // deletes a session in the middle of the transaction to insure
 // that we properly remove pendingcreatestream objects from
 // the spdy_session
 TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrentDelete) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
@@ skipping 116 matching lines @@
   HttpNetworkTransaction* transaction_;
   CompletionCallback callback_;
 };
 
 }  // namespace
 
 // Similar to ThreeGetsMaxConcurrrentDelete above, however, this test
 // closes the socket while we have a pending transaction waiting for
 // a pending stream creation.  http://crbug.com/52901
 TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrentSocketClose) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fin_body(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
@@ skipping 73 matching lines @@
   out.status_line = response2->headers->GetStatusLine();
   out.response_info = *response2;
   out.rv = ReadTransaction(&trans2, &out.response_data);
   EXPECT_EQ(ERR_CONNECTION_RESET, out.rv);
 
   helper.VerifyDataConsumed();
 }
 
 // Test that a simple PUT request works.
 TEST_P(SpdyNetworkTransactionTest, Put) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Setup the request
   HttpRequestInfo request;
   request.method = "PUT";
   request.url = GURL("http://www.google.com/");
 
   const SpdyHeaderInfo kSynStartHeader = {
     SYN_STREAM,             // Kind = Syn
     1,                      // Stream ID
     0,                      // Associated stream ID
     ConvertRequestPriorityToSpdyPriority(
@@ skipping 47 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
 }
 
 // Test that a simple HEAD request works.
 TEST_P(SpdyNetworkTransactionTest, Head) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Setup the request
   HttpRequestInfo request;
   request.method = "HEAD";
   request.url = GURL("http://www.google.com/");
 
   const SpdyHeaderInfo kSynStartHeader = {
     SYN_STREAM,             // Kind = Syn
     1,                      // Stream ID
     0,                      // Associated stream ID
     ConvertRequestPriorityToSpdyPriority(
@@ skipping 48 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, Post) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*body),  // POST upload frame
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(2, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreatePostRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a POST with a file works.
 TEST_P(SpdyNetworkTransactionTest, FilePost) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*body),  // POST upload frame
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(2, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateFilePostRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a complex POST works.
 TEST_P(SpdyNetworkTransactionTest, ComplexPost) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*body),  // POST upload frame
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
@@ skipping 10 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a chunked POST works.
 TEST_P(SpdyNetworkTransactionTest, ChunkedPost) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*body),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*resp),
@@ skipping 16 matching lines @@
 
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ(kUploadData, out.response_data);
 }
 
 // Test that a chunked POST works with chunks appended after transaction starts.
 TEST_P(SpdyNetworkTransactionTest, DelayedChunkedPost) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> chunk1(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> chunk2(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> chunk3(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*chunk1),
     CreateMockWrite(*chunk2),
     CreateMockWrite(*chunk3),
   };
@@ skipping 36 matching lines @@
   expected_response += kUploadData;
 
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ(expected_response, out.response_data);
 }
 
 // Test that a POST without any post data works.
 TEST_P(SpdyNetworkTransactionTest, NullPost) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(kRequestUrl);
   // Create an empty UploadData.
   request.upload_data_stream = NULL;
 
   // When request.upload_data_stream is NULL for post, content-length is
   // expected to be 0.
   scoped_ptr<SpdyFrame> req(
@@ skipping 19 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, EmptyPost) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Create an empty UploadDataStream.
   ScopedVector<UploadElementReader> element_readers;
   UploadDataStream stream(&element_readers, 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(kRequestUrl);
   request.upload_data_stream = &stream;
 
@@ skipping 21 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // While we're doing a post, the server sends back a SYN_REPLY.
 TEST_P(SpdyNetworkTransactionTest, PostWithEarlySynReply) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   static const char upload[] = { "hello!" };
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
       new UploadBytesElementReader(upload, sizeof(upload)));
   UploadDataStream stream(&element_readers, 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(kRequestUrl);
@@ skipping 33 matching lines @@
   data.RunFor(2);
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, rv);
   data.RunFor(1);
 }
 
 // The client upon cancellation tries to send a RST_STREAM frame. The mock
 // socket causes the TCP write to return zero. This test checks that the client
 // tries to queue up the RST_STREAM frame again.
 TEST_P(SpdyNetworkTransactionTest, SocketWriteReturnsZero) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockWrite writes[] = {
     CreateMockWrite(*req.get(), 0, SYNCHRONOUS),
     MockWrite(SYNCHRONOUS, 0, 0, 2),
     CreateMockWrite(*rst.get(), 3, SYNCHRONOUS),
   };
 
@@ skipping 21 matching lines @@
   data.Run();
   helper.ResetTrans();
   data.SetStop(20);
   data.Run();
 
   helper.VerifyDataConsumed();
 }
 
 // Test that the transaction doesn't crash when we don't have a reply.
 TEST_P(SpdyNetworkTransactionTest, ResponseWithoutSynReply) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(1, reads, arraysize(reads), NULL, 0);
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 }
 
 // Test that the transaction doesn't crash when we get two replies on the same
 // stream ID. See http://crbug.com/45639.
 TEST_P(SpdyNetworkTransactionTest, ResponseWithTwoSynReplies) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_STREAM_IN_USE));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*rst),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
@@ skipping 47 matching lines @@
 // enough number of WINDOW_UPDATEs to finish the first read and cause a
 // write, leading to a complete write of request body; after that we send
 // a reply with a body, to cause a graceful shutdown.
 
 // TODO(agayev): develop a socket data provider where both, reads and
 // writes are ordered so that writing tests like these are easy and rewrite
 // all these tests using it.  Right now we are working around the
 // limitations as described above and it's not deterministic, tests may
 // fail under specific circumstances.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateReceived) {
-  if (GetParam().protocol != kProtoSPDY3)
+  if (GetParam().protocol < kProtoSPDY3)
     return;
 
   static int kFrameCount = 2;
   scoped_ptr<std::string> content(
       new std::string(kMaxSpdyFrameChunkSize, 'a'));
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
       kRequestUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(
           1, content->c_str(), content->size(), false));
@@ skipping 70 matching lines @@
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   helper.VerifyDataConsumed();
 }
 
 // Test that received data frames and sent WINDOW_UPDATE frames change
 // the recv_window_size_ correctly.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateSent) {
-  if (GetParam().protocol != kProtoSPDY3)
+  if (GetParam().protocol < kProtoSPDY3)
     return;
 
   // Set the data in the body frame large enough to trigger sending a
   // WINDOW_UPDATE by the stream.
   const std::string body_data(kSpdyStreamInitialWindowSize / 2 + 1, 'x');
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+  scoped_ptr<SpdyFrame> session_window_update(
+      spdy_util_.ConstructSpdyWindowUpdate(0, body_data.size()));
   scoped_ptr<SpdyFrame> window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, body_data.size()));
 
-  MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*window_update),
-  };
+  std::vector<MockWrite> writes;
+  writes.push_back(CreateMockWrite(*req));
+  if (GetParam().protocol >= kProtoSPDY31)
+    writes.push_back(CreateMockWrite(*session_window_update));
+  writes.push_back(CreateMockWrite(*window_update));
 
   scoped_ptr<SpdyFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body_no_fin(
       spdy_util_.ConstructSpdyBodyFrame(
           1, body_data.data(), body_data.size(), false));
   scoped_ptr<SpdyFrame> body_fin(
       spdy_util_.ConstructSpdyBodyFrame(1, NULL, 0, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body_no_fin),
     MockRead(ASYNC, ERR_IO_PENDING, 0),  // Force a pause
     CreateMockRead(*body_fin),
     MockRead(ASYNC, ERR_IO_PENDING, 0),  // Force a pause
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+                         vector_as_array(&writes), writes.size());
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
 
@@ skipping 32 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 
   // Read EOF.
   data.CompleteRead();
 
   helper.VerifyDataConsumed();
 }
 
 // Test that WINDOW_UPDATE frame causing overflow is handled correctly.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateOverflow) {
-  if (GetParam().protocol != kProtoSPDY3)
+  if (GetParam().protocol < kProtoSPDY3)
     return;
 
   // Number of full frames we hope to write (but will not, used to
   // set content-length header correctly)
   static int kFrameCount = 3;
 
   scoped_ptr<std::string> content(
       new std::string(kMaxSpdyFrameChunkSize, 'a'));
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
       kRequestUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL, 0));
@@ skipping 61 matching lines @@
 // also contains a FIN flag.  DelayedSocketData is used to enforce all
 // writes go through before a read could happen.  However, the last frame
 // ("hello!")  is not supposed to go through since by the time its turn
 // arrives, window size is 0.  At this point MessageLoop::Run() called via
 // callback would block.  Therefore we call MessageLoop::RunUntilIdle()
 // which returns after performing all possible writes.  We use DCHECKS to
 // ensure that last data frame is still there and stream has stalled.
 // After that, next read is artifically enforced, which causes a
 // WINDOW_UPDATE to be read and I/O process resumes.
 TEST_P(SpdyNetworkTransactionTest, FlowControlStallResume) {
-  if (GetParam().protocol != kProtoSPDY3)
+  if (GetParam().protocol < kProtoSPDY3)
     return;
 
   // Number of frames we need to send to zero out the window size: data
   // frames plus SYN_STREAM plus the last data frame; also we need another
   // data frame that we will send once the WINDOW_UPDATE is received,
   // therefore +3.
   size_t num_writes = kSpdyStreamInitialWindowSize / kMaxSpdyFrameChunkSize + 3;
 
   // Calculate last frame's size; 0 size data frame is legal.
   size_t last_frame_size =
@@ skipping 23 matching lines @@
   scoped_ptr<MockWrite[]> writes(new MockWrite[num_writes]);
   size_t i = 0;
   writes[i] = CreateMockWrite(*req);
   for (i = 1; i < num_writes - 2; i++)
     writes[i] = CreateMockWrite(*body1);
   writes[i++] = CreateMockWrite(*body2);
   writes[i] = CreateMockWrite(*body3);
 
   // Construct read frame, give enough space to upload the rest of the
   // data.
+  scoped_ptr<SpdyFrame> session_window_update(
+      spdy_util_.ConstructSpdyWindowUpdate(0, kUploadDataSize));
   scoped_ptr<SpdyFrame> window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, kUploadDataSize));
   scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
+    CreateMockRead(*session_window_update),
+    CreateMockRead(*session_window_update),
     CreateMockRead(*window_update),
     CreateMockRead(*window_update),
     CreateMockRead(*reply),
     CreateMockRead(*body2),
     CreateMockRead(*body3),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
+  // Skip the session window updates unless we're using SPDY/3.1 and
+  // above.
+  size_t read_offset = (GetParam().protocol >= kProtoSPDY31) ? 0 : 2;
+  size_t num_reads = arraysize(reads) - read_offset;
+
   // Force all writes to happen before any read, last write will not
   // actually queue a frame, due to window size being 0.
-  DelayedSocketData data(num_writes, reads, arraysize(reads),
+  DelayedSocketData data(num_writes, reads + read_offset, num_reads,
                          writes.get(), num_writes);
 
   ScopedVector<UploadElementReader> element_readers;
   std::string upload_data_string(kSpdyStreamInitialWindowSize, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size()));
   UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
@@ skipping 26 matching lines @@
   EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
 
   data.ForceNextRead();   // Read in WINDOW_UPDATE frame.
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
 }
 
 // Test we correctly handle the case where the SETTINGS frame results in
 // unstalling the send window.
 TEST_P(SpdyNetworkTransactionTest, FlowControlStallResumeAfterSettings) {
-  if (GetParam().protocol != kProtoSPDY3)
+  if (GetParam().protocol < kProtoSPDY3)
     return;
 
   // Number of frames we need to send to zero out the window size: data
   // frames plus SYN_STREAM plus the last data frame; also we need another
   // data frame that we will send once the SETTING is received, therefore +3.
   size_t num_writes = kSpdyStreamInitialWindowSize / kMaxSpdyFrameChunkSize + 3;
 
   // Calculate last frame's size; 0 size data frame is legal.
   size_t last_frame_size =
       kSpdyStreamInitialWindowSize % kMaxSpdyFrameChunkSize;
@@ skipping 31 matching lines @@
   // rest of the data.
   SettingsMap settings;
   settings[SETTINGS_INITIAL_WINDOW_SIZE] =
       SettingsFlagsAndValue(
           SETTINGS_FLAG_NONE, kSpdyStreamInitialWindowSize * 2);
   scoped_ptr<SpdyFrame> settings_frame_large(
       spdy_util_.ConstructSpdySettings(settings));
 
   reads.push_back(CreateMockRead(*settings_frame_large, i++));
 
+  scoped_ptr<SpdyFrame> session_window_update(
+      spdy_util_.ConstructSpdyWindowUpdate(0, kUploadDataSize));
+  if (GetParam().protocol >= kProtoSPDY31)
+    reads.push_back(CreateMockRead(*session_window_update, i++));
+
   writes.push_back(CreateMockWrite(*body3, i++));
 
   scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   reads.push_back(CreateMockRead(*reply, i++));
   reads.push_back(CreateMockRead(*body2, i++));
   reads.push_back(CreateMockRead(*body3, i++));
   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
 
   // Force all writes to happen before any read, last write will not
   // actually queue a frame, due to window size being 0.
@@ skipping 41 matching lines @@
   data.RunFor(6);   // Read in SETTINGS frame to unstall.
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
   // If stream is NULL, that means it was unstalled and closed.
   EXPECT_TRUE(stream->stream() == NULL);
 }
 
 // Test we correctly handle the case where the SETTINGS frame results in a
 // negative send window size.
 TEST_P(SpdyNetworkTransactionTest, FlowControlNegativeSendWindowSize) {
-  if (GetParam().protocol != kProtoSPDY3)
+  if (GetParam().protocol < kProtoSPDY3)
     return;
 
   // Number of frames we need to send to zero out the window size: data
   // frames plus SYN_STREAM plus the last data frame; also we need another
   // data frame that we will send once the SETTING is received, therefore +3.
   size_t num_writes = kSpdyStreamInitialWindowSize / kMaxSpdyFrameChunkSize + 3;
 
   // Calculate last frame's size; 0 size data frame is legal.
   size_t last_frame_size =
       kSpdyStreamInitialWindowSize % kMaxSpdyFrameChunkSize;
@@ skipping 28 matching lines @@
   writes.push_back(CreateMockWrite(*body2, i++));
 
   // Construct read frame for SETTINGS that makes the send_window_size
   // negative.
   SettingsMap new_settings;
   new_settings[SETTINGS_INITIAL_WINDOW_SIZE] =
       SettingsFlagsAndValue(
           SETTINGS_FLAG_NONE, kSpdyStreamInitialWindowSize / 2);
   scoped_ptr<SpdyFrame> settings_frame_small(
       spdy_util_.ConstructSpdySettings(new_settings));
-  // Construct read frame for WINDOW_UPDATE that makes the send_window_size
-  // postive.
+  // Construct read frames for WINDOW_UPDATE that makes the send_window_size
+  // positive.
+  scoped_ptr<SpdyFrame> session_window_update_init_size(
+      spdy_util_.ConstructSpdyWindowUpdate(0, kSpdyStreamInitialWindowSize));
   scoped_ptr<SpdyFrame> window_update_init_size(
       spdy_util_.ConstructSpdyWindowUpdate(1, kSpdyStreamInitialWindowSize));
 
   reads.push_back(CreateMockRead(*settings_frame_small, i++));
+
+  if (GetParam().protocol >= kProtoSPDY3)
+    reads.push_back(CreateMockRead(*session_window_update_init_size, i++));
+
   reads.push_back(CreateMockRead(*window_update_init_size, i++));
 
   writes.push_back(CreateMockWrite(*body3, i++));
 
   scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   reads.push_back(CreateMockRead(*reply, i++));
   reads.push_back(CreateMockRead(*body2, i++));
   reads.push_back(CreateMockRead(*body3, i++));
   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
 
@@ skipping 33 matching lines @@
   EXPECT_EQ(0, stream->stream()->send_window_size());
 
   // All the body data should have been read.
   // TODO(satorux): This is because of the weirdness in reading the request
   // body in OnSendBodyComplete(). See crbug.com/113107.
   EXPECT_TRUE(upload_data_stream.IsEOF());
   // But the body is not yet fully sent (kUploadData is not yet sent)
   // since we're send-stalled.
   EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
 
-  data.RunFor(7);   // Read in WINDOW_UPDATE or SETTINGS frame.
+  // Read in WINDOW_UPDATE or SETTINGS frame.
+  data.RunFor((GetParam().protocol >= kProtoSPDY31) ? 8 : 7);
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, ResetReplyWithTransferEncoding) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*rst),
   };
 
@@ skipping 16 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 
   helper.session()->spdy_session_pool()->CloseAllSessions();
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, ResetPushWithTransferEncoding) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*rst),
   };
 
@@ skipping 20 matching lines @@
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   helper.session()->spdy_session_pool()->CloseAllSessions();
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, CancelledTransaction) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
@@ skipping 20 matching lines @@
   helper.ResetTrans();  // Cancel the transaction.
 
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   base::MessageLoop::current()->RunUntilIdle();
   helper.VerifyDataNotConsumed();
 }
 
 // Verify that the client sends a Rst Frame upon cancelling the stream.
 TEST_P(SpdyNetworkTransactionTest, CancelledTransactionSendRst) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockWrite writes[] = {
     CreateMockWrite(*req, 0, SYNCHRONOUS),
     CreateMockWrite(*rst, 2, SYNCHRONOUS),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
@@ skipping 25 matching lines @@
   data.SetStop(20);
   data.Run();
 
   helper.VerifyDataConsumed();
 }
 
 // Verify that the client can correctly deal with the user callback attempting
 // to start another transaction on a session that is closing down. See
 // http://crbug.com/47455
 TEST_P(SpdyNetworkTransactionTest, StartTransactionOnReadCallback) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
   MockWrite writes2[] = { CreateMockWrite(*req) };
 
   // The indicated length of this frame is longer than its actual length. When
   // the session receives an empty frame after this one, it shuts down the
   // session, and calls the read callback with the incomplete data.
   const uint8 kGetBodyFrame2[] = {
     0x00, 0x00, 0x00, 0x01,
@@ skipping 44 matching lines @@
   data.CompleteRead();
   // This finishes the read.
   data.CompleteRead();
   helper.VerifyDataConsumed();
 }
 
 // Verify that the client can correctly deal with the user callback deleting the
 // transaction. Failures will usually be valgrind errors. See
 // http://crbug.com/46925
 TEST_P(SpdyNetworkTransactionTest, DeleteSessionOnReadCallback) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp.get(), 2),
     MockRead(ASYNC, ERR_IO_PENDING, 3),  // Force a pause
     CreateMockRead(*body.get(), 4),
@@ skipping 27 matching lines @@
   ASSERT_EQ(ERR_IO_PENDING, rv);
   data.CompleteRead();
 
   // Finish running rest of tasks.
   base::MessageLoop::current()->RunUntilIdle();
   helper.VerifyDataConsumed();
 }
 
 // Send a spdy request to www.google.com that gets redirected to www.foo.com.
 TEST_P(SpdyNetworkTransactionTest, RedirectGetRequest) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   const SpdyHeaderInfo kSynStartHeader = spdy_util_.MakeSpdyHeader(SYN_STREAM);
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock("http://www.google.com/"));
   (*headers)["user-agent"] = "";
   (*headers)["accept-encoding"] = "gzip,deflate";
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructGetHeaderBlock("http://www.foo.com/index.php"));
   (*headers2)["user-agent"] = "";
   (*headers2)["accept-encoding"] = "gzip,deflate";
 
@@ skipping 56 matching lines @@
   }
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
   EXPECT_TRUE(data2.at_read_eof());
   EXPECT_TRUE(data2.at_write_eof());
 }
 
 // Send a spdy request to www.google.com. Get a pushed stream that redirects to
 // www.foo.com.
 TEST_P(SpdyNetworkTransactionTest, RedirectServerPush) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   const SpdyHeaderInfo kSynStartHeader = spdy_util_.MakeSpdyHeader(SYN_STREAM);
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock("http://www.google.com/"));
   (*headers)["user-agent"] = "";
   (*headers)["accept-encoding"] = "gzip,deflate";
 
   // Setup writes/reads to www.google.com
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyFrame(kSynStartHeader, headers.Pass()));
@@ skipping 82 matching lines @@
   }
   data.CompleteRead();
   data2.CompleteRead();
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
   EXPECT_TRUE(data2.at_read_eof());
   EXPECT_TRUE(data2.at_write_eof());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
-  static const unsigned char kPushBodyFrame[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x06,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame>
       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
+  const char kPushedData[] = "pushed";
+  scoped_ptr<SpdyFrame> stream2_body(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
-             arraysize(kPushBodyFrame), 5),
+    CreateMockRead(*stream2_body, 5),
     MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushBeforeSynReply) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
-  static const unsigned char kPushBodyFrame[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x06,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame>
       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
+  const char kPushedData[] = "pushed";
+  scoped_ptr<SpdyFrame> stream2_body(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
     CreateMockRead(*stream2_syn, 2),
     CreateMockRead(*stream1_reply, 3),
     CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
-             arraysize(kPushBodyFrame), 5),
+    CreateMockRead(*stream2_body, 5),
     MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame2) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
-  static const unsigned char kPushBodyFrame[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x06,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*stream1_syn, 1), };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame>
       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
+  const char kPushedData[] = "pushed";
+  scoped_ptr<SpdyFrame> stream2_body(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
   scoped_ptr<SpdyFrame>
       stream1_body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
-             arraysize(kPushBodyFrame), 5),
-    CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
+    CreateMockRead(*stream2_body, 4),
+    CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
     MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushServerAborted) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
@@ skipping 40 matching lines @@
                                     << data.write_count()
                                     << " Write index: "
                                     << data.write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
+// Verify that we don't leak streams and that we properly send a reset
+// if the server pushes the same stream twice.
 TEST_P(SpdyNetworkTransactionTest, ServerPushDuplicate) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
-  // Verify that we don't leak streams and that we properly send a reset
-  // if the server pushes the same stream twice.
-  static const unsigned char kPushBodyFrame[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x06,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
-
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   scoped_ptr<SpdyFrame> stream3_rst(
       spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
     CreateMockWrite(*stream3_rst, 5),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame>
       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
+  const char kPushedData[] = "pushed";
+  scoped_ptr<SpdyFrame> stream2_body(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
   scoped_ptr<SpdyFrame>
       stream3_syn(spdy_util_.ConstructSpdyPush(NULL,
                                     0,
                                     4,
                                     1,
                                     "http://www.google.com/foo.dat"));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream3_syn, 4),
     CreateMockRead(*stream1_body, 6, SYNCHRONOUS),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
-             arraysize(kPushBodyFrame), 7),
+    CreateMockRead(*stream2_body, 7),
     MockRead(ASYNC, ERR_IO_PENDING, 8),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrame) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
-  static const unsigned char kPushBodyFrame1[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x1F,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
-  static const char kPushBodyFrame2[] = " my darling";
-  static const char kPushBodyFrame3[] = " hello";
-  static const char kPushBodyFrame4[] = " my baby";
-
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame>
       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
+  static const char kPushedData[] = "pushed my darling hello my baby";
+  scoped_ptr<SpdyFrame> stream2_body_base(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
+  const size_t kChunkSize = strlen(kPushedData) / 4;
+  scoped_ptr<SpdyFrame> stream2_body1(
+      new SpdyFrame(stream2_body_base->data(), kChunkSize, false));
+  scoped_ptr<SpdyFrame> stream2_body2(
+      new SpdyFrame(stream2_body_base->data() + kChunkSize, kChunkSize, false));
+  scoped_ptr<SpdyFrame> stream2_body3(
+      new SpdyFrame(stream2_body_base->data() + 2 * kChunkSize,
+                    kChunkSize, false));
+  scoped_ptr<SpdyFrame> stream2_body4(
+      new SpdyFrame(stream2_body_base->data() + 3 * kChunkSize,
+                    stream2_body_base->size() - 3 * kChunkSize, false));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame1),
-             arraysize(kPushBodyFrame1), 4),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame2),
-             arraysize(kPushBodyFrame2) - 1, 5),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame3),
-             arraysize(kPushBodyFrame3) - 1, 6),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame4),
-             arraysize(kPushBodyFrame4) - 1, 7),
+    CreateMockRead(*stream2_body1, 4),
+    CreateMockRead(*stream2_body2, 5),
+    CreateMockRead(*stream2_body3, 6),
+    CreateMockRead(*stream2_body4, 7),
     CreateMockRead(*stream1_body, 8, SYNCHRONOUS),
     MockRead(ASYNC, ERR_IO_PENDING, 9),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed my darling hello my baby");
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
-  RunServerPushTest(&data,
-                    &response,
-                    &response2,
-                    expected_push_result);
+  RunServerPushTest(&data, &response, &response2, kPushedData);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrameInterrupted) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
-  static const unsigned char kPushBodyFrame1[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x1F,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
-  static const char kPushBodyFrame2[] = " my darling";
-  static const char kPushBodyFrame3[] = " hello";
-  static const char kPushBodyFrame4[] = " my baby";
-
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame>
       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
+  static const char kPushedData[] = "pushed my darling hello my baby";
+  scoped_ptr<SpdyFrame> stream2_body_base(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
+  const size_t kChunkSize = strlen(kPushedData) / 4;
+  scoped_ptr<SpdyFrame> stream2_body1(
+      new SpdyFrame(stream2_body_base->data(), kChunkSize, false));
+  scoped_ptr<SpdyFrame> stream2_body2(
+      new SpdyFrame(stream2_body_base->data() + kChunkSize, kChunkSize, false));
+  scoped_ptr<SpdyFrame> stream2_body3(
+      new SpdyFrame(stream2_body_base->data() + 2 * kChunkSize,
+                    kChunkSize, false));
+  scoped_ptr<SpdyFrame> stream2_body4(
+      new SpdyFrame(stream2_body_base->data() + 3 * kChunkSize,
+                    stream2_body_base->size() - 3 * kChunkSize, false));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame1),
-             arraysize(kPushBodyFrame1), 4),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame2),
-             arraysize(kPushBodyFrame2) - 1, 5),
+    CreateMockRead(*stream2_body1, 4),
+    CreateMockRead(*stream2_body2, 5),
     MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame3),
-             arraysize(kPushBodyFrame3) - 1, 7),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame4),
-             arraysize(kPushBodyFrame4) - 1, 8),
+    CreateMockRead(*stream2_body3, 7),
+    CreateMockRead(*stream2_body4, 8),
     CreateMockRead(*stream1_body.get(), 9, SYNCHRONOUS),
     MockRead(ASYNC, ERR_IO_PENDING, 10)  // Force a pause.
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
-  std::string expected_push_result("pushed my darling hello my baby");
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
-  RunServerPushTest(&data,
-                    &response,
-                    &response2,
-                    expected_push_result);
+  RunServerPushTest(&data, &response, &response2, kPushedData);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   scoped_ptr<SpdyFrame> stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
     CreateMockWrite(*stream2_rst, 4),
   };
@@ skipping 41 matching lines @@
                                     << " Write index: "
                                     << data.write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID9) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   scoped_ptr<SpdyFrame> stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_INVALID_STREAM));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
     CreateMockWrite(*stream2_rst, 4),
   };
@@ skipping 41 matching lines @@
                                     << " Write index: "
                                     << data.write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushNoURL) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   scoped_ptr<SpdyFrame> stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
     CreateMockWrite(*stream2_rst, 4),
   };
@@ skipping 49 matching lines @@
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 // Verify that various SynReply headers parse correctly through the
 // HTTP layer.
 TEST_P(SpdyNetworkTransactionTest, SynReplyHeaders) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   struct SynReplyHeadersTests {
     int num_headers;
     const char* extra_headers[5];
     SpdyHeaderBlock expected_headers;
   } test_cases[] = {
     // This uses a multi-valued cookie header.
     { 2,
       { "cookie", "val1",
         "cookie", "val2",  // will get appended separated by NULL
         NULL
@@ skipping 67 matching lines @@
         header_block[name] += value;
       }
     }
     EXPECT_EQ(test_cases[i].expected_headers, header_block);
   }
 }
 
 // Verify that various SynReply headers parse vary fields correctly
 // through the HTTP layer, and the response matches the request.
 TEST_P(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   static const SpdyHeaderInfo syn_reply_info = {
     SYN_REPLY,                              // Syn Reply
     1,                                      // Stream ID
     0,                                      // Associated Stream ID
     ConvertRequestPriorityToSpdyPriority(
         LOWEST, spdy_util_.spdy_version()),
     kSpdyCredentialSlotUnused,
     CONTROL_FLAG_NONE,                      // Control Flags
     false,                                  // Compressed
     RST_STREAM_INVALID,                     // Status
@@ skipping 149 matching lines @@
                         test_cases[i].num_headers[1],
                         &reply_headers);
     std::string expected_reply =
         spdy_util_.ConstructSpdyReplyString(reply_headers);
     EXPECT_EQ(expected_reply, lines) << i;
   }
 }
 
 // Verify that we don't crash on invalid SynReply responses.
 TEST_P(SpdyNetworkTransactionTest, InvalidSynReply) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   const SpdyHeaderInfo kSynStartHeader = {
     SYN_REPLY,              // Kind = SynReply
     1,                      // Stream ID
     0,                      // Associated stream ID
     ConvertRequestPriorityToSpdyPriority(
         LOWEST, spdy_util_.spdy_version()),
     kSpdyCredentialSlotUnused,
     CONTROL_FLAG_NONE,      // Control Flags
     false,                  // Compressed
     RST_STREAM_INVALID,     // Status
@@ skipping 52 matching lines @@
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
   }
 }
 
 // Verify that we don't crash on some corrupt frames.
 TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionError) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // This is the length field that's too short.
   scoped_ptr<SpdyFrame> syn_reply_wrong_length(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-  size_t wrong_size = syn_reply_wrong_length->size() - 4;
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
+  size_t right_size =
+      (spdy_util_.spdy_version() < SPDY4) ?
+      syn_reply_wrong_length->size() - framer.GetControlFrameHeaderSize() :
+      syn_reply_wrong_length->size();
+  size_t wrong_size = right_size - 4;
   test::SetFrameLength(syn_reply_wrong_length.get(),
-                       wrong_size - framer.GetControlFrameHeaderSize(),
+                       wrong_size,
                        spdy_util_.spdy_version());
 
   struct SynReplyTests {
     const SpdyFrame* syn_reply;
   } test_cases[] = {
     { syn_reply_wrong_length.get(), },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
@@ skipping 13 matching lines @@
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
   }
 }
 
 // Test that we shutdown correctly on write errors.
 TEST_P(SpdyNetworkTransactionTest, WriteError) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = {
     // We'll write 10 bytes successfully
     MockWrite(ASYNC, req->data(), 10),
     // Followed by ERROR!
     MockWrite(ASYNC, ERR_FAILED),
   };
 
   DelayedSocketData data(2, NULL, 0,
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_FAILED, out.rv);
   data.Reset();
 }
 
 // Test that partial writes work.
 TEST_P(SpdyNetworkTransactionTest, PartialWrite) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Chop the SYN_STREAM frame into 5 chunks.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   const int kChunks = 5;
   scoped_ptr<MockWrite[]> writes(ChopWriteFrame(*req.get(), kChunks));
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   DelayedSocketData data(kChunks, reads, arraysize(reads),
                          writes.get(), kChunks);
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // In this test, we enable compression, but get a uncompressed SynReply from
 // the server.  Verify that teardown is all clean.
 TEST_P(SpdyNetworkTransactionTest, DecompressFailureOnSynReply) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> compressed(
       spdy_util_.ConstructSpdyGet(NULL, 0, true, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*compressed),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
   };
 
   DelayedSocketData data(1, reads, arraysize(reads),
                          writes, arraysize(writes));
   SpdySessionDependencies* session_deps =
       CreateSpdySessionDependencies(GetParam());
   session_deps->enable_compression = true;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), session_deps);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
   data.Reset();
 }
 
 // Test that the NetLog contains good data for a simple GET request.
 TEST_P(SpdyNetworkTransactionTest, NetLog) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   static const char* const kExtraHeaders[] = {
     "user-agent",   "Chrome",
   };
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(kExtraHeaders, 1, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
@@ skipping 68 matching lines @@
     EXPECT_NE(header_list->end(), header_list->Find(header)) <<
         "Header not found: " << *it;
   }
 }
 
 // Since we buffer the IO from the stream to the renderer, this test verifies
 // that when we read out the maximum amount of data (e.g. we received 50 bytes
 // on the network, but issued a Read for only 5 of those bytes) that the data
 // flow still works correctly.
 TEST_P(SpdyNetworkTransactionTest, BufferFull) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // 2 data frames in a single read.
   scoped_ptr<SpdyFrame> data_frame_1(
       framer.CreateDataFrame(1, "goodby", 6, DATA_FLAG_NONE));
   scoped_ptr<SpdyFrame> data_frame_2(
@@ skipping 74 matching lines @@
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("goodbye world", out.response_data);
 }
 
 // Verify that basic buffering works; when multiple data frames arrive
 // at the same time, ensure that we don't notify a read completion for
 // each data frame individually.
 TEST_P(SpdyNetworkTransactionTest, Buffering) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // 4 data frames in a single read.
   scoped_ptr<SpdyFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
   scoped_ptr<SpdyFrame> data_frame_fin(
@@ skipping 75 matching lines @@
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
 
 // Verify the case where we buffer data but read it after it has been buffered.
 TEST_P(SpdyNetworkTransactionTest, BufferedAll) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // 5 data frames in a single read.
   scoped_ptr<SpdyFrame> syn_reply(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   // turn off FIN bit
@@ skipping 74 matching lines @@
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
 
 // Verify the case where we buffer data and close the connection.
 TEST_P(SpdyNetworkTransactionTest, BufferedClosed) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // All data frames in a single read.
   // NOTE: We don't FIN the stream.
   scoped_ptr<SpdyFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
@@ skipping 71 matching lines @@
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // Verify the case where we buffer data and cancel the transaction.
 TEST_P(SpdyNetworkTransactionTest, BufferedCancelled) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // NOTE: We don't FIN the stream.
   scoped_ptr<SpdyFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
 
@@ skipping 52 matching lines @@
   // to run for the final time.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // Test that if the server requests persistence of settings, that we save
 // the settings in the HttpServerProperties.
 TEST_P(SpdyNetworkTransactionTest, SettingsSaved) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   static const SpdyHeaderInfo kSynReplyInfo = {
     SYN_REPLY,                              // Syn Reply
     1,                                      // Stream ID
     0,                                      // Associated Stream ID
     ConvertRequestPriorityToSpdyPriority(
         LOWEST, spdy_util_.spdy_version()),
     kSpdyCredentialSlotUnused,
     CONTROL_FLAG_NONE,                      // Control Flags
     false,                                  // Compressed
     RST_STREAM_INVALID,                     // Status
@@ skipping 84 matching lines @@
     EXPECT_TRUE(it3 != settings_map.end());
     SettingsFlagsAndValue flags_and_value3 = it3->second;
     EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value3.first);
     EXPECT_EQ(kSampleValue3, flags_and_value3.second);
   }
 }
 
 // Test that when there are settings saved that they are sent back to the
 // server upon session establishment.
 TEST_P(SpdyNetworkTransactionTest, SettingsPlayback) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   static const SpdyHeaderInfo kSynReplyInfo = {
     SYN_REPLY,                              // Syn Reply
     1,                                      // Stream ID
     0,                                      // Associated Stream ID
     ConvertRequestPriorityToSpdyPriority(
         LOWEST, spdy_util_.spdy_version()),
     kSpdyCredentialSlotUnused,
     CONTROL_FLAG_NONE,                      // Control Flags
     false,                                  // Compressed
     RST_STREAM_INVALID,                     // Status
@@ skipping 92 matching lines @@
     // Verify the second persisted setting.
     SettingsMap::const_iterator it2 = settings_map.find(kSampleId2);
     EXPECT_TRUE(it2 != settings_map.end());
     SettingsFlagsAndValue flags_and_value2 = it2->second;
     EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value2.first);
     EXPECT_EQ(kSampleValue2, flags_and_value2.second);
   }
 }
 
 TEST_P(SpdyNetworkTransactionTest, GoAwayWithActiveStream) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<SpdyFrame> go_away(spdy_util_.ConstructSpdyGoAway());
   MockRead reads[] = {
     CreateMockRead(*go_away),
     MockRead(ASYNC, 0, 0),  // EOF
   };
 
   DelayedSocketData data(1, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_ABORTED, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, CloseWithActiveStream) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
 
@@ skipping 19 matching lines @@
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, out.rv);
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // Test to make sure we can correctly connect through a proxy.
 TEST_P(SpdyNetworkTransactionTest, ProxyConnect) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.session_deps().reset(CreateSpdySessionDependencies(
       GetParam(),
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70")));
   helper.SetSession(make_scoped_refptr(
       SpdySessionDependencies::SpdyCreateSession(helper.session_deps().get())));
   helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
@@ skipping 83 matching lines @@
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans, &response_data));
   EXPECT_EQ("hello!", response_data);
   helper.VerifyDataConsumed();
 }
 
 // Test to make sure we can correctly connect through a proxy to www.google.com,
 // if there already exists a direct spdy connection to www.google.com. See
 // http://crbug.com/49874
 TEST_P(SpdyNetworkTransactionTest, DirectConnectProxyReconnect) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // When setting up the first transaction, we store the SpdySessionPool so that
   // we can use the same pool in the second transaction.
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
 
   // Use a proxy service which returns a proxy fallback list from DIRECT to
   // myproxy:70. For this test there will be no fallback, so it is equivalent
   // to simply DIRECT. The reason for appending the second proxy is to verify
   // that the session pool key used does is just "DIRECT".
   helper.session_deps().reset(CreateSpdySessionDependencies(
@@ skipping 161 matching lines @@
 
   data.CompleteRead();
   helper_proxy.VerifyDataConsumed();
 }
 
 // When we get a TCP-level RST, we need to retry a HttpNetworkTransaction
 // on a new connection, if the connection was previously known to be good.
 // This can happen when a server reboots without saying goodbye, or when
 // we're behind a NAT that masked the RST.
 TEST_P(SpdyNetworkTransactionTest, VerifyRetryOnConnectionReset) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
     MockRead(ASYNC, ERR_IO_PENDING),
     MockRead(ASYNC, ERR_CONNECTION_RESET),
   };
 
   MockRead reads2[] = {
@@ skipping 58 matching lines @@
       EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
       EXPECT_EQ("hello!", response_data);
     }
 
     helper.VerifyDataConsumed();
   }
 }
 
 // Test that turning SPDY on and off works properly.
 TEST_P(SpdyNetworkTransactionTest, SpdyOnOffToggle) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   net::HttpStreamFactory::set_spdy_enabled(true);
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
@@ skipping 24 matching lines @@
   TransactionHelperResult out2 = helper2.output();
   EXPECT_EQ(OK, out2.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out2.status_line);
   EXPECT_EQ("hello from http", out2.response_data);
 
   net::HttpStreamFactory::set_spdy_enabled(true);
 }
 
 // Tests that Basic authentication works over SPDY
 TEST_P(SpdyNetworkTransactionTest, SpdyBasicAuth) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   net::HttpStreamFactory::set_spdy_enabled(true);
 
   // The first request will be a bare GET, the second request will be a
   // GET with an Authorization header.
   scoped_ptr<SpdyFrame> req_get(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   const char* const kExtraAuthorizationHeaders[] = {
     "authorization", "Basic Zm9vOmJhcg=="
   };
   scoped_ptr<SpdyFrame> req_get_authorization(
@@ skipping 70 matching lines @@
   // TODO(cbentzel): This is actually the same response object as before, but
   // data has changed.
   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
   ASSERT_TRUE(response_restart != NULL);
   ASSERT_TRUE(response_restart->headers.get() != NULL);
   EXPECT_EQ(200, response_restart->headers->response_code());
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushWithHeaders) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
-  static const unsigned char kPushBodyFrame[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x06,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 1),
   };
 
   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
   spdy_util_.AddUrlToHeaderBlock(
@@ skipping 15 matching lines @@
       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
                                            false,
                                            2,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
                                            0));
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  const char kPushedData[] = "pushed";
+  scoped_ptr<SpdyFrame> stream2_body(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream2_headers, 4),
     CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
-             arraysize(kPushBodyFrame), 6),
+    CreateMockRead(*stream2_body, 5),
     MockRead(ASYNC, ERR_IO_PENDING, 7),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushClaimBeforeHeaders) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // We push a stream and attempt to claim it before the headers come down.
-  static const unsigned char kPushBodyFrame[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x06,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
   spdy_util_.AddUrlToHeaderBlock(
@@ skipping 15 matching lines @@
       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
                                            false,
                                            2,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
                                            0));
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  const char kPushedData[] = "pushed";
+  scoped_ptr<SpdyFrame> stream2_body(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 1),
     CreateMockRead(*stream2_syn, 2),
     CreateMockRead(*stream1_body, 3),
     CreateMockRead(*stream2_headers, 4),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
-             arraysize(kPushBodyFrame), 5),
+    CreateMockRead(*stream2_body, 5),
     MockRead(ASYNC, 0, 6),  // EOF
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
@@ skipping 59 matching lines @@
 
   // Read the final EOF (which will close the session)
   data.RunFor(1);
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushWithTwoHeaderFrames) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // We push a stream and attempt to claim it before the headers come down.
-  static const unsigned char kPushBodyFrame[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x06,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
   spdy_util_.AddUrlToHeaderBlock(
@@ skipping 25 matching lines @@
       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
                                            false,
                                            2,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
                                            0));
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  const char kPushedData[] = "pushed";
+  scoped_ptr<SpdyFrame> stream2_body(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 1),
     CreateMockRead(*stream2_syn, 2),
     CreateMockRead(*stream1_body, 3),
     CreateMockRead(*stream2_headers1, 4),
     CreateMockRead(*stream2_headers2, 5),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
-             arraysize(kPushBodyFrame), 6),
+    CreateMockRead(*stream2_body, 6),
     MockRead(ASYNC, 0, 7),  // EOF
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
@@ skipping 72 matching lines @@
 
   // Read the final EOF (which will close the session)
   data.RunFor(1);
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushWithNoStatusHeaderFrames) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // We push a stream and attempt to claim it before the headers come down.
-  static const unsigned char kPushBodyFrame[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x06,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
   spdy_util_.AddUrlToHeaderBlock(
@@ skipping 13 matching lines @@
       spdy_util_.ConstructSpdyControlFrame(middle_headers.Pass(),
                                            false,
                                            2,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
                                            0));
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  const char kPushedData[] = "pushed";
+  scoped_ptr<SpdyFrame> stream2_body(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 1),
     CreateMockRead(*stream2_syn, 2),
     CreateMockRead(*stream1_body, 3),
     CreateMockRead(*stream2_headers1, 4),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
-             arraysize(kPushBodyFrame), 5),
+    CreateMockRead(*stream2_body, 5),
     MockRead(ASYNC, 0, 6),  // EOF
   };
 
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.SetDeterministic();
   helper.AddDeterministicData(&data);
@@ skipping 49 matching lines @@
 
   // Read the final EOF (which will close the session).
   data.RunFor(1);
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
 }
 
 TEST_P(SpdyNetworkTransactionTest, SynReplyWithHeaders) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*rst),
  };
 
   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
@@ skipping 30 matching lines @@
   DelayedSocketData data(1, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, SynReplyWithLateHeaders) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*rst),
   };
 
   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
@@ skipping 33 matching lines @@
   DelayedSocketData data(1, reads, arraysize(reads),
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushCrossOriginCorrectness) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // In this test we want to verify that we can't accidentally push content
   // which can't be pushed by this content server.
   // This test assumes that:
   //   - if we're requesting http://www.foo.com/barbaz
   //   - the browser has made a connection to "www.foo.com".
 
   // A list of the URL to fetch, followed by the URL being pushed.
   static const char* const kTestCases[] = {
     "http://www.google.com/foo.html",
     "http://www.google.com:81/foo.js",     // Bad port
 
     "http://www.google.com/foo.html",
     "https://www.google.com/foo.js",       // Bad protocol
 
     "http://www.google.com/foo.html",
     "ftp://www.google.com/foo.js",         // Invalid Protocol
 
     "http://www.google.com/foo.html",
     "http://blat.www.google.com/foo.js",   // Cross subdomain
 
     "http://www.google.com/foo.html",
     "http://www.foo.com/foo.js",           // Cross domain
   };
 
-
-  static const unsigned char kPushBodyFrame[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x06,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
-
   for (size_t index = 0; index < arraysize(kTestCases); index += 2) {
     const char* url_to_fetch = kTestCases[index];
     const char* url_to_push = kTestCases[index + 1];
 
     scoped_ptr<SpdyFrame> stream1_syn(
         spdy_util_.ConstructSpdyGet(url_to_fetch, false, 1, LOWEST));
     scoped_ptr<SpdyFrame> stream1_body(
         spdy_util_.ConstructSpdyBodyFrame(1, true));
     scoped_ptr<SpdyFrame> push_rst(
         spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
     MockWrite writes[] = {
       CreateMockWrite(*stream1_syn, 1),
       CreateMockWrite(*push_rst, 4),
     };
 
     scoped_ptr<SpdyFrame>
         stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
     scoped_ptr<SpdyFrame>
         stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                                  0,
                                                  2,
                                                  1,
                                                  url_to_push));
+    const char kPushedData[] = "pushed";
+    scoped_ptr<SpdyFrame> stream2_body(
+        spdy_util_.ConstructSpdyBodyFrame(
+            2, kPushedData, strlen(kPushedData), true));
     scoped_ptr<SpdyFrame> rst(
         spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_CANCEL));
 
     MockRead reads[] = {
       CreateMockRead(*stream1_reply, 2),
       CreateMockRead(*stream2_syn, 3),
       CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
-      MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
-               arraysize(kPushBodyFrame), 6),
+      CreateMockRead(*stream2_body, 6),
       MockRead(ASYNC, ERR_IO_PENDING, 7),  // Force a pause
     };
 
     HttpResponseInfo response;
     OrderedSocketData data(reads, arraysize(reads),
                            writes, arraysize(writes));
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL(url_to_fetch);
@@ skipping 33 matching lines @@
 
     VerifyStreamsClosed(helper);
 
     // Verify the SYN_REPLY.
     EXPECT_TRUE(response.headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
   }
 }
 
 TEST_P(SpdyNetworkTransactionTest, RetryAfterRefused) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*req, 1),
     CreateMockWrite(*req2, 3),
   };
 
@@ skipping 36 matching lines @@
                                     << " Write index: "
                                     << data.write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, OutOfOrderSynStream) {
-  if (GetParam().protocol > kProtoSPDY3)
-    return;
-
   // This first request will start to establish the SpdySession.
   // Then we will start the second (MEDIUM priority) and then third
   // (HIGHEST priority) request in such a way that the third will actually
   // start before the second, causing the second to be numbered differently
   // than the order they were created.
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, HIGHEST, true));
   scoped_ptr<SpdyFrame> req3(
@@ skipping 66 matching lines @@
   // And now we can allow everything else to run to completion.
   data.SetStop(10);
   data.Run();
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(OK, callback3.WaitForResult());
 
   helper.VerifyDataConsumed();
 }
 
 }  // namespace net