Remove SPDY/3.1 tests.

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 <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 47 matching lines @@
 
 namespace net {
 
 namespace {
 
 using testing::Each;
 using testing::Eq;
 
 const int32_t kBufferSize = SpdyHttpStream::kRequestBodyBufferSize;
 
-struct SpdyNetworkTransactionTestParams {
-  SpdyNetworkTransactionTestParams()
-      : protocol(kProtoSPDY31),
-        priority_to_dependency(false) {}
-
-  SpdyNetworkTransactionTestParams(NextProto protocol,
-                                   bool priority_to_dependency)
-      : protocol(protocol),
-        priority_to_dependency(priority_to_dependency) {}
-
-  friend std::ostream& operator<<(std::ostream& os,
-                                  const SpdyNetworkTransactionTestParams& p) {
-    os << "{ protocol: " << SSLClientSocket::NextProtoToString(p.protocol)
-       << ", priority_to_dependency: " << p.priority_to_dependency << " }";
-    return os;
-  }
-
-  NextProto protocol;
-  bool priority_to_dependency;
-};
-
-void UpdateSpdySessionDependencies(SpdyNetworkTransactionTestParams test_params,
-                                   SpdySessionDependencies* session_deps) {
-  session_deps->enable_priority_dependencies =
-      test_params.priority_to_dependency;
-}
-
 std::unique_ptr<SpdySessionDependencies> CreateSpdySessionDependencies(
-    SpdyNetworkTransactionTestParams test_params) {
+    bool priority_to_dependency) {
   std::unique_ptr<SpdySessionDependencies> session_deps(
-      new SpdySessionDependencies(test_params.protocol));
-  UpdateSpdySessionDependencies(test_params, session_deps.get());
+      new SpdySessionDependencies());
+  session_deps->enable_priority_dependencies = priority_to_dependency;
   return session_deps;
 }
 
 std::unique_ptr<SpdySessionDependencies> CreateSpdySessionDependencies(
-    SpdyNetworkTransactionTestParams test_params,
+    bool priority_to_dependency,
     std::unique_ptr<ProxyService> proxy_service) {
   std::unique_ptr<SpdySessionDependencies> session_deps(
-      new SpdySessionDependencies(test_params.protocol,
-                                  std::move(proxy_service)));
-  UpdateSpdySessionDependencies(test_params, session_deps.get());
+      new SpdySessionDependencies(std::move(proxy_service)));
+  session_deps->enable_priority_dependencies = priority_to_dependency;
   return session_deps;
 }
 
 }  // namespace
 
-class SpdyNetworkTransactionTest
-    : public ::testing::TestWithParam<SpdyNetworkTransactionTestParams> {
+class SpdyNetworkTransactionTest : public ::testing::TestWithParam<bool> {
  protected:
   SpdyNetworkTransactionTest()
       : default_url_(kDefaultUrl),
         host_port_pair_(HostPortPair::FromURL(default_url_)),
-        spdy_util_(GetParam().protocol, GetParam().priority_to_dependency) {}
+        spdy_util_(GetParam()) {}
 
   virtual ~SpdyNetworkTransactionTest() {
     // UploadDataStream may post a deletion tasks back to the message loop on
     // destruction.
     upload_data_stream_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void SetUp() override {
     get_request_initialized_ = false;
     post_request_initialized_ = false;
     chunked_post_request_initialized_ = false;
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   struct TransactionHelperResult {
     int rv;
     std::string status_line;
     std::string response_data;
     HttpResponseInfo response_info;
   };
 
   // A helper class that handles all the initial npn/ssl setup.
   class NormalSpdyTransactionHelper {
    public:
     NormalSpdyTransactionHelper(
         const HttpRequestInfo& request,
         RequestPriority priority,
         const BoundNetLog& log,
-        SpdyNetworkTransactionTestParams test_params,
+        bool priority_to_dependency,
         std::unique_ptr<SpdySessionDependencies> session_deps)
         : request_(request),
           priority_(priority),
-          session_deps_(session_deps.get() == NULL
-                            ? CreateSpdySessionDependencies(test_params)
-                            : std::move(session_deps)),
+          session_deps_(
+              session_deps.get() == NULL
+                  ? CreateSpdySessionDependencies(priority_to_dependency)
+                  : std::move(session_deps)),
           session_(
               SpdySessionDependencies::SpdyCreateSession(session_deps_.get())),
           log_(log),
-          test_params_(test_params),
+          priority_to_dependency_(priority_to_dependency),
           spdy_enabled_(true) {}
 
     ~NormalSpdyTransactionHelper() {
       // Any test which doesn't close the socket by sending it an EOF will
       // have a valid session left open, which leaks the entire session pool.
       // This is just fine - in fact, some of our tests intentionally do this
       // so that we can check consistency of the SpdySessionPool as the test
       // finishes.  If we had put an EOF on the socket, the SpdySession would
       // have closed and we wouldn't be able to check the consistency.
 
       // Forcefully close existing sessions here.
       session()->spdy_session_pool()->CloseAllSessions();
     }
 
     void SetSpdyDisabled() {
       spdy_enabled_ = false;
     }
 
     void RunPreTestSetup() {
       if (!session_deps_.get())
-        session_deps_ = CreateSpdySessionDependencies(test_params_);
+        session_deps_ = CreateSpdySessionDependencies(priority_to_dependency_);
       if (!session_.get()) {
         session_ = SpdySessionDependencies::SpdyCreateSession(
             session_deps_.get());
       }
 
       // We're now ready to use SSL-npn SPDY.
       trans_.reset(new HttpNetworkTransaction(priority_, session_.get()));
     }
 
     // Start the transaction, read some data, finish.
@@ skipping 16 matching lines @@
       if (output_.rv != OK) {
         session_->spdy_session_pool()->CloseCurrentSessions(ERR_ABORTED);
         return;
       }
 
       // Verify responses.
       const HttpResponseInfo* response = trans_->GetResponseInfo();
       ASSERT_TRUE(response);
       ASSERT_TRUE(response->headers);
       if (HttpStreamFactory::spdy_enabled()) {
-        EXPECT_EQ(
-            HttpResponseInfo::ConnectionInfoFromNextProto(
-                test_params_.protocol),
-            response->connection_info);
+        EXPECT_EQ(HttpResponseInfo::ConnectionInfoFromNextProto(kProtoHTTP2),
+                  response->connection_info);
       } else {
         EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1,
                   response->connection_info);
       }
       if (spdy_enabled_) {
         EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
         EXPECT_TRUE(response->was_fetched_via_spdy);
         EXPECT_TRUE(response->was_npn_negotiated);
       } else {
         EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 61 matching lines @@
           ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
       AddDataWithSSLSocketDataProvider(data, std::move(ssl_provider));
     }
 
     void AddDataWithSSLSocketDataProvider(
         SocketDataProvider* data,
         std::unique_ptr<SSLSocketDataProvider> ssl_provider) {
       data_vector_.push_back(data);
       if (ssl_provider->next_proto_status ==
           SSLClientSocket::kNextProtoUnsupported) {
-        ssl_provider->SetNextProto(test_params_.protocol);
+        ssl_provider->SetNextProto(kProtoHTTP2);
       }
 
       session_deps_->socket_factory->AddSSLSocketDataProvider(
           ssl_provider.get());
       ssl_vector_.push_back(std::move(ssl_provider));
 
       session_deps_->socket_factory->AddSocketDataProvider(data);
     }
 
     void SetSession(std::unique_ptr<HttpNetworkSession> session) {
       session_ = std::move(session);
     }
     HttpNetworkTransaction* trans() { return trans_.get(); }
     void ResetTrans() { trans_.reset(); }
     TransactionHelperResult& output() { return output_; }
     const HttpRequestInfo& request() const { return request_; }
     HttpNetworkSession* session() const { return session_.get(); }
     std::unique_ptr<SpdySessionDependencies>& session_deps() {
       return session_deps_;
     }
-    SpdyNetworkTransactionTestParams test_params() const {
-      return test_params_;
-    }
 
    private:
     typedef std::vector<SocketDataProvider*> DataVector;
     typedef std::vector<std::unique_ptr<SSLSocketDataProvider>> SSLVector;
     typedef std::vector<std::unique_ptr<SocketDataProvider>> AlternateVector;
     HttpRequestInfo request_;
     RequestPriority priority_;
     std::unique_ptr<SpdySessionDependencies> session_deps_;
     std::unique_ptr<HttpNetworkSession> session_;
     TransactionHelperResult output_;
     std::unique_ptr<SocketDataProvider> first_transaction_;
     SSLVector ssl_vector_;
     TestCompletionCallback callback_;
     std::unique_ptr<HttpNetworkTransaction> trans_;
     std::unique_ptr<HttpNetworkTransaction> trans_http_;
     DataVector data_vector_;
     AlternateVector alternate_vector_;
     const BoundNetLog log_;
-    SpdyNetworkTransactionTestParams test_params_;
+    bool priority_to_dependency_;
     bool spdy_enabled_;
   };
 
   void ConnectStatusHelperWithExpectedStatus(const MockRead& status,
                                              int expected_status);
 
   void ConnectStatusHelper(const MockRead& status);
 
   const HttpRequestInfo& CreateGetPushRequest() {
     get_push_request_.method = "GET";
@@ skipping 270 matching lines @@
   bool get_request_initialized_;
   bool post_request_initialized_;
   bool chunked_post_request_initialized_;
   HttpRequestInfo get_request_;
   HttpRequestInfo post_request_;
   HttpRequestInfo chunked_post_request_;
   HttpRequestInfo get_push_request_;
   base::ScopedTempDir temp_dir_;
 };
 
-//-----------------------------------------------------------------------------
-// All tests are run with three different connection types: SPDY after NPN
-// negotiation, SPDY without SSL, and SPDY with SSL.
-//
-// TODO(akalin): Use ::testing::Combine() when we are able to use
-// <tr1/tuple>.
-INSTANTIATE_TEST_CASE_P(
-    Spdy,
-    SpdyNetworkTransactionTest,
-    ::testing::Values(SpdyNetworkTransactionTestParams(kProtoSPDY31, false),
-                      SpdyNetworkTransactionTestParams(kProtoSPDY31, true),
-                      SpdyNetworkTransactionTestParams(kProtoHTTP2, false),
-                      SpdyNetworkTransactionTestParams(kProtoHTTP2, true)));
+INSTANTIATE_TEST_CASE_P(Spdy, SpdyNetworkTransactionTest, ::testing::Bool());
 
 // Verify HttpNetworkTransaction constructor.
 TEST_P(SpdyNetworkTransactionTest, Constructor) {
   std::unique_ptr<SpdySessionDependencies> session_deps(
       CreateSpdySessionDependencies(GetParam()));
   std::unique_ptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(session_deps.get()));
   std::unique_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 }
@@ skipping 20 matching lines @@
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 TEST_P(SpdyNetworkTransactionTest, GetAtEachPriority) {
   for (RequestPriority p = MINIMUM_PRIORITY; p <= MAXIMUM_PRIORITY;
        p = RequestPriority(p + 1)) {
-    SpdyTestUtil spdy_test_util(GetParam().protocol,
-                                GetParam().priority_to_dependency);
+    SpdyTestUtil spdy_test_util(GetParam());
 
     // Construct the request.
     std::unique_ptr<SpdySerializedFrame> req(
         spdy_test_util.ConstructSpdyGet(nullptr, 0, 1, p, true));
     MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
     SpdyPriority spdy_prio = 0;
-    EXPECT_TRUE(
-        GetSpdyPriority(spdy_test_util.spdy_version(), *req, &spdy_prio));
+    EXPECT_TRUE(GetSpdyPriority(*req, &spdy_prio));
     // this repeats the RequestPriority-->SpdyPriority mapping from
     // SpdyFramer::ConvertRequestPriorityToSpdyPriority to make
     // sure it's being done right.
     switch (p) {
       case HIGHEST:
         EXPECT_EQ(0, spdy_prio);
         break;
       case MEDIUM:
         EXPECT_EQ(1, spdy_prio);
         break;
@@ skipping 1152 matching lines @@
   expected_response += kUploadData;
 
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ(expected_response, out.response_data);
 }
 
 // Test that a POST without any post data works.
 TEST_P(SpdyNetworkTransactionTest, NullPost) {
-  BufferedSpdyFramer framer(spdy_util_.spdy_version());
+  BufferedSpdyFramer framer(HTTP2);
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = default_url_;
   // 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.
   SpdyHeaderBlock req_block(
@@ skipping 21 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, EmptyPost) {
-  BufferedSpdyFramer framer(spdy_util_.spdy_version());
+  BufferedSpdyFramer framer(HTTP2);
   // Create an empty UploadDataStream.
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   ElementsUploadDataStream stream(std::move(element_readers), 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = default_url_;
   request.upload_data_stream = &stream;
 
@@ skipping 494 matching lines @@
     CreateMockRead(*body2, 3),
     MockRead(ASYNC, 0, 0, 4)  // EOF
   };
 
   SequencedSocketData data2(reads2, arraysize(reads2), writes2,
                             arraysize(writes2));
 
   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   TestDelegate d;
   {
-    SpdyURLRequestContext spdy_url_request_context(GetParam().protocol);
+    SpdyURLRequestContext spdy_url_request_context;
     std::unique_ptr<URLRequest> r(spdy_url_request_context.CreateRequest(
         default_url_, DEFAULT_PRIORITY, &d));
     spdy_url_request_context.socket_factory().
         AddSocketDataProvider(&data);
     spdy_url_request_context.socket_factory().
         AddSocketDataProvider(&data2);
 
     d.set_quit_on_redirect(true);
     r->Start();
     base::RunLoop().Run();
@@ skipping 61 matching lines @@
   };
   MockRead reads2[] = {
     CreateMockRead(*resp2, 2),
     CreateMockRead(*body2, 3),
     MockRead(ASYNC, 0, 0, 5)  // EOF
   };
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   SequencedSocketData data2(reads2, arraysize(reads2), writes2,
                             arraysize(writes2));
 
-  // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   TestDelegate d;
   TestDelegate d2;
-  SpdyURLRequestContext spdy_url_request_context(GetParam().protocol);
+  SpdyURLRequestContext spdy_url_request_context;
   {
     std::unique_ptr<URLRequest> r(spdy_url_request_context.CreateRequest(
         default_url_, DEFAULT_PRIORITY, &d));
     spdy_url_request_context.socket_factory().
         AddSocketDataProvider(&data);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(0, d.received_redirect_count());
@@ skipping 355 matching lines @@
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers);
   EXPECT_EQ("HTTP/1.1 200", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) {
   std::unique_ptr<SpdySerializedFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> goaway;
-  if (spdy_util_.spdy_version() == SPDY3) {
-    goaway.reset(spdy_util_.ConstructSpdyGoAway(0, GOAWAY_PROTOCOL_ERROR,
-                                                "Push on even stream id."));
-  } else {
     goaway.reset(spdy_util_.ConstructSpdyGoAway(
         0, GOAWAY_PROTOCOL_ERROR, "Framer error: 1 (INVALID_STREAM_ID)."));
-  }
   MockWrite writes[] = {
       CreateMockWrite(*stream1_syn, 0), CreateMockWrite(*goaway, 3),
   };
 
   std::unique_ptr<SpdySerializedFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 0, GetDefaultUrlWithPath("/foo.dat").c_str()));
   MockRead reads[] = {
       CreateMockRead(*stream1_reply, 1),
@@ skipping 84 matching lines @@
   std::unique_ptr<SpdySerializedFrame> stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
       CreateMockWrite(*stream1_syn, 0), CreateMockWrite(*stream2_rst, 3),
   };
 
   std::unique_ptr<SpdySerializedFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   SpdyHeaderBlock incomplete_headers;
   incomplete_headers[spdy_util_.GetStatusKey()] = "200 OK";
-  incomplete_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   incomplete_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(incomplete_headers), 2,
                                                1));
   MockRead reads[] = {
       CreateMockRead(*stream1_reply, 1),
       CreateMockRead(*stream2_syn, 2),
       CreateMockRead(*stream1_body, 4),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5)  // Force a pause
   };
@@ skipping 186 matching lines @@
       { "cookie", "val1,val2",
         NULL
       },
     }
   };
 
   test_cases[0].expected_headers["status"] = "200";
   test_cases[1].expected_headers["status"] = "200";
   test_cases[2].expected_headers["status"] = "200";
 
-  // HTTP/2 eliminates use of the :version header.
-  if (GetParam().protocol == kProtoSPDY31) {
-    test_cases[0].expected_headers["version"] = "HTTP/1.1";
-    test_cases[1].expected_headers["version"] = "HTTP/1.1";
-    test_cases[2].expected_headers["version"] = "HTTP/1.1";
-  }
-
   test_cases[0].expected_headers["hello"] = "bye";
   test_cases[1].expected_headers["hello"] = "bye";
   test_cases[2].expected_headers["hello"] = "bye";
 
   test_cases[0].expected_headers["cookie"] = base::StringPiece("val1\0val2", 9);
   test_cases[2].expected_headers["cookie"] = "val1,val2";
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    SpdyTestUtil spdy_test_util(GetParam().protocol,
-                                GetParam().priority_to_dependency);
+    SpdyTestUtil spdy_test_util(GetParam());
     std::unique_ptr<SpdySerializedFrame> req(
         spdy_test_util.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
     MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
     std::unique_ptr<SpdySerializedFrame> resp(
         spdy_test_util.ConstructSpdyGetSynReply(test_cases[i].extra_headers,
                                                 test_cases[i].num_headers, 1));
     std::unique_ptr<SpdySerializedFrame> body(
         spdy_test_util.ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
@@ skipping 39 matching lines @@
 TEST_P(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
   // Modify the following data to change/add test cases:
   struct SynReplyTests {
     bool vary_matches;
     int num_headers[2];
     const char* extra_headers[2][16];
   } test_cases[] = {
       // Test the case of a multi-valued cookie.  When the value is delimited
       // with NUL characters, it needs to be unfolded into multiple headers.
       {true,
-       {1, 4},
+       {1, 3},
        {{"cookie", "val1,val2", NULL},
         {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
-         "/index.php", spdy_util_.GetVersionKey(), "HTTP/1.1", "vary", "cookie",
-         NULL}}},
+         "/index.php", "vary", "cookie", NULL}}},
       {// Multiple vary fields.
        true,
-       {2, 5},
-       {{"friend", "barney", "enemy", "snaggletooth", NULL},
-        {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
-         "/index.php", spdy_util_.GetVersionKey(), "HTTP/1.1", "vary", "friend",
-         "vary", "enemy", NULL}}},
-      {// Test a '*' vary field.
-       false,
-       {1, 4},
-       {{"cookie", "val1,val2", NULL},
-        {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
-         "/index.php", spdy_util_.GetVersionKey(), "HTTP/1.1", "vary", "*",
-         NULL}}},
-      {// Multiple comma-separated vary fields.
-       true,
        {2, 4},
        {{"friend", "barney", "enemy", "snaggletooth", NULL},
         {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
-         "/index.php", spdy_util_.GetVersionKey(), "HTTP/1.1", "vary",
-         "friend,enemy", NULL}}}};
+         "/index.php", "vary", "friend", "vary", "enemy", NULL}}},
+      {// Test a '*' vary field.
+       false,
+       {1, 3},
+       {{"cookie", "val1,val2", NULL},
+        {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
+         "/index.php", "vary", "*", NULL}}},
+      {// Multiple comma-separated vary fields.
+       true,
+       {2, 3},
+       {{"friend", "barney", "enemy", "snaggletooth", NULL},
+        {spdy_util_.GetStatusKey(), "200", spdy_util_.GetPathKey(),
+         "/index.php", "vary", "friend,enemy", NULL}}}};
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    SpdyTestUtil spdy_test_util(GetParam().protocol,
-                                GetParam().priority_to_dependency);
+    SpdyTestUtil spdy_test_util(GetParam());
 
     // Construct the request.
     std::unique_ptr<SpdySerializedFrame> frame_req(
         spdy_test_util.ConstructSpdyGet(test_cases[i].extra_headers[0],
                                         test_cases[i].num_headers[0], 1, LOWEST,
                                         true));
 
     MockWrite writes[] = {
         CreateMockWrite(*frame_req, 0),
     };
@@ skipping 60 matching lines @@
 }
 
 // Verify that we don't crash on invalid SynReply responses.
 TEST_P(SpdyNetworkTransactionTest, InvalidSynReply) {
   struct InvalidSynReplyTests {
     int num_headers;
     const char* headers[10];
   } test_cases[] = {
       // SYN_REPLY missing status header
       {
-          4,
-          {spdy_util_.GetPathKey(), "/index.php", spdy_util_.GetVersionKey(),
-           "HTTP/1.1", "cookie", "val1", "cookie", "val2", NULL},
+          3,
+          {spdy_util_.GetPathKey(), "/index.php", "cookie", "val1", "cookie",
+           "val2", NULL},
       },
       // SYN_REPLY missing version header
       {
-          2, {spdy_util_.GetPathKey(), "/index.php", "status", "200", NULL},
+          1, {spdy_util_.GetPathKey(), "/index.php", "status", "200", NULL},
       },
       // SYN_REPLY with no headers
       {
           0, {NULL},
       },
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    SpdyTestUtil spdy_test_util(GetParam().protocol,
-                                GetParam().priority_to_dependency);
+    SpdyTestUtil spdy_test_util(GetParam());
 
     std::unique_ptr<SpdySerializedFrame> req(
         spdy_test_util.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
     std::unique_ptr<SpdySerializedFrame> rst(
         spdy_test_util.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
     MockWrite writes[] = {
         CreateMockWrite(*req, 0), CreateMockWrite(*rst, 2),
     };
 
     // Construct the reply.
@@ skipping 10 matching lines @@
                              arraysize(writes));
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
     EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
   }
 }
 
 TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionError) {
-  if (spdy_util_.spdy_version() != SPDY3) {
-    return;
-  }
-
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> goaway(spdy_util_.ConstructSpdyGoAway(
-      0, GOAWAY_COMPRESSION_ERROR, "Framer error: 5 (DECOMPRESS_FAILURE)."));
-  MockWrite writes[] = {
-      CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 3),
-  };
-
-  // This is the length field that's too short.
-  std::unique_ptr<SpdySerializedFrame> syn_reply_wrong_length(
-      spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
-  size_t right_size =
-      syn_reply_wrong_length->size() -
-      SpdyConstants::GetControlFrameHeaderSize(spdy_util_.spdy_version());
-  size_t wrong_size = right_size - 4;
-  test::SetFrameLength(syn_reply_wrong_length.get(),
-                       wrong_size,
-                       spdy_util_.spdy_version());
-  std::unique_ptr<SpdySerializedFrame> body(
-      spdy_util_.ConstructSpdyBodyFrame(1, true));
-  MockRead reads[] = {
-      MockRead(ASYNC, syn_reply_wrong_length->data(),
-               syn_reply_wrong_length->size(), 1),
-      CreateMockRead(*body, 2),
-  };
-
-  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
-  NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
-                                     BoundNetLog(), GetParam(), nullptr);
-  helper.RunToCompletion(&data);
-  TransactionHelperResult out = helper.output();
-  EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
-}
-
-TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionErrorSpdy4) {
-  if (spdy_util_.spdy_version() != HTTP2) {
-    return;
-  }
-
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  std::unique_ptr<SpdySerializedFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_COMPRESSION_ERROR, "Framer error: 6 (DECOMPRESS_FAILURE)."));
   MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2)};
 
   // This is the length field that's too short.
   std::unique_ptr<SpdySerializedFrame> syn_reply_wrong_length(
       spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
-  size_t right_size =
-      syn_reply_wrong_length->size() -
-      SpdyConstants::GetControlFrameHeaderSize(spdy_util_.spdy_version());
+  size_t right_size = syn_reply_wrong_length->size() -
+                      SpdyConstants::GetControlFrameHeaderSize(HTTP2);
   size_t wrong_size = right_size - 4;
-  test::SetFrameLength(syn_reply_wrong_length.get(),
-                       wrong_size,
-                       spdy_util_.spdy_version());
+  test::SetFrameLength(syn_reply_wrong_length.get(), wrong_size, HTTP2);
 
   MockRead reads[] = {
       MockRead(ASYNC, syn_reply_wrong_length->data(),
                syn_reply_wrong_length->size() - 4, 1),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsError(ERR_SPDY_COMPRESSION_ERROR));
 }
 
 TEST_P(SpdyNetworkTransactionTest, GoAwayOnDecompressionFailure) {
-  if (GetParam().protocol < kProtoHTTP2) {
-    // Decompression failures are a stream error in SPDY3.
-    return;
-  }
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_COMPRESSION_ERROR, "Framer error: 6 (DECOMPRESS_FAILURE)."));
   MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2)};
 
   // Read HEADERS with corrupted payload.
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   memset(resp->data() + 12, 0xcf, resp->size() - 12);
@@ skipping 11 matching lines @@
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_FRAME_SIZE_ERROR,
       "Framer error: 15 (INVALID_CONTROL_FRAME_SIZE)."));
   MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2)};
 
   // Read WINDOW_UPDATE with incorrectly-sized payload.
   std::unique_ptr<SpdySerializedFrame> bad_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, 1));
-  test::SetFrameLength(bad_window_update.get(),
-                       bad_window_update->size() - 1,
-                       spdy_util_.spdy_version());
+  test::SetFrameLength(bad_window_update.get(), bad_window_update->size() - 1,
+                       HTTP2);
   MockRead reads[] = {CreateMockRead(*bad_window_update, 1)};
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(
       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsError(ERR_SPDY_FRAME_SIZE_ERROR));
 }
 
@@ skipping 110 matching lines @@
                                    NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
                                    NetLog::PHASE_END);
   pos = ExpectLogContainsSomewhere(entries, pos + 1,
                                    NetLog::TYPE_HTTP_TRANSACTION_READ_BODY,
                                    NetLog::PHASE_BEGIN);
   pos = ExpectLogContainsSomewhere(entries, pos + 1,
                                    NetLog::TYPE_HTTP_TRANSACTION_READ_BODY,
                                    NetLog::PHASE_END);
 
   // Check that we logged all the headers correctly
-  const NetLog::EventType type = (GetParam().protocol == kProtoSPDY31)
-                                     ? NetLog::TYPE_HTTP2_SESSION_SYN_STREAM
-                                     : NetLog::TYPE_HTTP2_SESSION_SEND_HEADERS;
-  pos = ExpectLogContainsSomewhere(entries, 0, type, NetLog::PHASE_NONE);
+  pos = ExpectLogContainsSomewhere(
+      entries, 0, NetLog::TYPE_HTTP2_SESSION_SEND_HEADERS, NetLog::PHASE_NONE);
 
   base::ListValue* header_list;
   ASSERT_TRUE(entries[pos].params.get());
   ASSERT_TRUE(entries[pos].params->GetList("headers", &header_list));
 
   std::vector<std::string> expected;
   expected.push_back(std::string(spdy_util_.GetHostKey()) +
                      ": www.example.org");
   expected.push_back(std::string(spdy_util_.GetPathKey()) + ": /");
   expected.push_back(std::string(spdy_util_.GetSchemeKey()) + ": " +
                      default_url_.scheme());
   expected.push_back(std::string(spdy_util_.GetMethodKey()) + ": GET");
   expected.push_back("user-agent: Chrome");
-  if (spdy_util_.spdy_version() < HTTP2) {
-    // HTTP/2 eliminates use of the :version header.
-    expected.push_back(std::string(spdy_util_.GetVersionKey()) + ": HTTP/1.1");
-  }
   EXPECT_EQ(expected.size(), header_list->GetSize());
   for (std::vector<std::string>::const_iterator it = expected.begin();
        it != expected.end();
        ++it) {
     base::StringValue header(*it);
     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) {
-  BufferedSpdyFramer framer(spdy_util_.spdy_version());
+  BufferedSpdyFramer framer(HTTP2);
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // 2 data frames in a single read.
   std::unique_ptr<SpdySerializedFrame> data_frame_1(
       framer.CreateDataFrame(1, "goodby", 6, DATA_FLAG_NONE));
   std::unique_ptr<SpdySerializedFrame> data_frame_2(
       framer.CreateDataFrame(1, "e worl", 6, DATA_FLAG_NONE));
@@ skipping 72 matching lines @@
 
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", 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) {
-  BufferedSpdyFramer framer(spdy_util_.spdy_version());
+  BufferedSpdyFramer framer(HTTP2);
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // 4 data frames in a single read.
   std::unique_ptr<SpdySerializedFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
   std::unique_ptr<SpdySerializedFrame> data_frame_fin(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_FIN));
@@ skipping 71 matching lines @@
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", 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) {
-  BufferedSpdyFramer framer(spdy_util_.spdy_version());
+  BufferedSpdyFramer framer(HTTP2);
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // 5 data frames in a single read.
   std::unique_ptr<SpdySerializedFrame> reply(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
@@ skipping 65 matching lines @@
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
 
 // Verify the case where we buffer data and close the connection.
 TEST_P(SpdyNetworkTransactionTest, BufferedClosed) {
-  BufferedSpdyFramer framer(spdy_util_.spdy_version());
+  BufferedSpdyFramer framer(HTTP2);
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // All data frames in a single read.
   // NOTE: We don't FIN the stream.
   std::unique_ptr<SpdySerializedFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
   const SpdySerializedFrame* data_frames[4] = {
@@ skipping 66 matching lines @@
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   base::RunLoop().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) {
-  BufferedSpdyFramer framer(spdy_util_.spdy_version());
+  BufferedSpdyFramer framer(HTTP2);
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4)};
 
   // NOTE: We don't FIN the stream.
   std::unique_ptr<SpdySerializedFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
@@ skipping 46 matching lines @@
   helper.ResetTrans();
 
   // Flush the MessageLoop; this will cause the buffered IO task
   // to run for the final time.
   base::RunLoop().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 (spdy_util_.spdy_version() >= HTTP2) {
-    // HTTP/2 doesn't support settings persistence.
-    return;
-  }
-  static const SpdyHeaderInfo kSynReplyInfo = {
-      SYN_REPLY,  // Syn Reply
-      1,          // Stream ID
-      0,          // Associated Stream ID
-      ConvertRequestPriorityToSpdyPriority(LOWEST, spdy_util_.spdy_version()),
-      0,                   // Weight (unused)
-      CONTROL_FLAG_NONE,   // Control Flags
-      RST_STREAM_INVALID,  // Status
-      NULL,                // Data
-      0,                   // Data Length
-      DATA_FLAG_NONE       // Data Flags
-  };
-
-  BoundNetLog net_log;
-  NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
-                                     net_log, GetParam(), NULL);
-  helper.RunPreTestSetup();
-
-  // Verify that no settings exist initially.
-  url::SchemeHostPort spdy_server(default_url_);
-  SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
-  EXPECT_TRUE(spdy_session_pool->http_server_properties()
-                  ->GetSpdySettings(spdy_server)
-                  .empty());
-
-  // Construct the request.
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  MockWrite writes[] = {CreateMockWrite(*req, 0)};
-
-  // Construct the reply.
-  SpdyHeaderBlock reply_headers;
-  reply_headers[spdy_util_.GetStatusKey()] = "200";
-  reply_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
-  std::unique_ptr<SpdySerializedFrame> reply(
-      spdy_util_.ConstructSpdyFrame(kSynReplyInfo, std::move(reply_headers)));
-
-  const SpdySettingsIds kSampleId1 = SETTINGS_UPLOAD_BANDWIDTH;
-  unsigned int kSampleValue1 = 0x0a0a0a0a;
-  const SpdySettingsIds kSampleId2 = SETTINGS_DOWNLOAD_BANDWIDTH;
-  unsigned int kSampleValue2 = 0x0b0b0b0b;
-  const SpdySettingsIds kSampleId3 = SETTINGS_ROUND_TRIP_TIME;
-  unsigned int kSampleValue3 = 0x0c0c0c0c;
-  std::unique_ptr<SpdySerializedFrame> settings_frame;
-  {
-    // Construct the SETTINGS frame.
-    SettingsMap settings;
-    // First add a persisted setting.
-    settings[kSampleId1] =
-        SettingsFlagsAndValue(SETTINGS_FLAG_PLEASE_PERSIST, kSampleValue1);
-    // Next add a non-persisted setting.
-    settings[kSampleId2] =
-        SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kSampleValue2);
-    // Next add another persisted setting.
-    settings[kSampleId3] =
-        SettingsFlagsAndValue(SETTINGS_FLAG_PLEASE_PERSIST, kSampleValue3);
-    settings_frame.reset(spdy_util_.ConstructSpdySettings(settings));
-  }
-
-  std::unique_ptr<SpdySerializedFrame> body(
-      spdy_util_.ConstructSpdyBodyFrame(1, true));
-  MockRead reads[] = {
-      CreateMockRead(*reply, 1),
-      CreateMockRead(*body, 2),
-      CreateMockRead(*settings_frame, 3),
-      MockRead(ASYNC, 0, 4)  // EOF
-  };
-
-  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
-  helper.AddData(&data);
-  helper.RunDefaultTest();
-  helper.VerifyDataConsumed();
-  TransactionHelperResult out = helper.output();
-  EXPECT_THAT(out.rv, IsOk());
-  EXPECT_EQ("HTTP/1.1 200", out.status_line);
-  EXPECT_EQ("hello!", out.response_data);
-
-  {
-    // Verify we had two persisted settings.
-    const SettingsMap& settings_map =
-        spdy_session_pool->http_server_properties()->GetSpdySettings(
-            spdy_server);
-    ASSERT_EQ(2u, settings_map.size());
-
-    // Verify the first persisted setting.
-    SettingsMap::const_iterator it1 = settings_map.find(kSampleId1);
-    EXPECT_TRUE(it1 != settings_map.end());
-    SettingsFlagsAndValue flags_and_value1 = it1->second;
-    EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value1.first);
-    EXPECT_EQ(kSampleValue1, flags_and_value1.second);
-
-    // Verify the second persisted setting.
-    SettingsMap::const_iterator it3 = settings_map.find(kSampleId3);
-    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 (spdy_util_.spdy_version() >= HTTP2) {
-    // HTTP/2 doesn't support settings persistence.
-    return;
-  }
-  static const SpdyHeaderInfo kSynReplyInfo = {
-      SYN_REPLY,  // Syn Reply
-      1,          // Stream ID
-      0,          // Associated Stream ID
-      ConvertRequestPriorityToSpdyPriority(LOWEST, spdy_util_.spdy_version()),
-      0,                   // Weight (unused)
-      CONTROL_FLAG_NONE,   // Control Flags
-      RST_STREAM_INVALID,  // Status
-      NULL,                // Data
-      0,                   // Data Length
-      DATA_FLAG_NONE       // Data Flags
-  };
-
-  BoundNetLog net_log;
-  NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
-                                     net_log, GetParam(), NULL);
-  helper.RunPreTestSetup();
-
-  SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
-
-  SpdySessionPoolPeer pool_peer(spdy_session_pool);
-  pool_peer.SetEnableSendingInitialData(true);
-
-  // Verify that no settings exist initially.
-  url::SchemeHostPort spdy_server(default_url_);
-  EXPECT_TRUE(spdy_session_pool->http_server_properties()
-                  ->GetSpdySettings(spdy_server)
-                  .empty());
-
-  const SpdySettingsIds kSampleId1 = SETTINGS_MAX_CONCURRENT_STREAMS;
-  unsigned int kSampleValue1 = 0x0a0a0a0a;
-  const SpdySettingsIds kSampleId2 = SETTINGS_INITIAL_WINDOW_SIZE;
-  unsigned int kSampleValue2 = 0x0c0c0c0c;
-
-  // First add a persisted setting.
-  spdy_session_pool->http_server_properties()->SetSpdySetting(
-      spdy_server, kSampleId1, SETTINGS_FLAG_PLEASE_PERSIST, kSampleValue1);
-
-  // Next add another persisted setting.
-  spdy_session_pool->http_server_properties()->SetSpdySetting(
-      spdy_server, kSampleId2, SETTINGS_FLAG_PLEASE_PERSIST, kSampleValue2);
-
-  EXPECT_EQ(2u, spdy_session_pool->http_server_properties()
-                    ->GetSpdySettings(spdy_server)
-                    .size());
-
-  // Construct the initial SETTINGS frame.
-  SettingsMap initial_settings;
-  initial_settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
-      SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kMaxConcurrentPushedStreams);
-  std::unique_ptr<SpdySerializedFrame> initial_settings_frame(
-      spdy_util_.ConstructSpdySettings(initial_settings));
-
-  // Construct the persisted SETTINGS frame.
-  const SettingsMap& settings =
-      spdy_session_pool->http_server_properties()->GetSpdySettings(spdy_server);
-  std::unique_ptr<SpdySerializedFrame> settings_frame(
-      spdy_util_.ConstructSpdySettings(settings));
-
-  // Construct the request.
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-
-  MockWrite writes[] = {
-      CreateMockWrite(*initial_settings_frame, 0),
-      CreateMockWrite(*settings_frame, 1),
-      CreateMockWrite(*req, 2),
-  };
-
-  // Construct the reply.
-  SpdyHeaderBlock reply_headers;
-  reply_headers[spdy_util_.GetStatusKey()] = "200";
-  reply_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
-  std::unique_ptr<SpdySerializedFrame> reply(
-      spdy_util_.ConstructSpdyFrame(kSynReplyInfo, std::move(reply_headers)));
-
-  std::unique_ptr<SpdySerializedFrame> body(
-      spdy_util_.ConstructSpdyBodyFrame(1, true));
-  MockRead reads[] = {
-      CreateMockRead(*reply, 3),
-      CreateMockRead(*body, 4),
-      MockRead(ASYNC, 0, 5)  // EOF
-  };
-
-  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
-  helper.AddData(&data);
-  helper.RunDefaultTest();
-  helper.VerifyDataConsumed();
-  TransactionHelperResult out = helper.output();
-  EXPECT_THAT(out.rv, IsOk());
-  EXPECT_EQ("HTTP/1.1 200", out.status_line);
-  EXPECT_EQ("hello!", out.response_data);
-
-  {
-    // Verify we had two persisted settings.
-    const SettingsMap& settings_map =
-        spdy_session_pool->http_server_properties()->GetSpdySettings(
-            spdy_server);
-    ASSERT_EQ(2u, settings_map.size());
-
-    // Verify the first persisted setting.
-    SettingsMap::const_iterator it1 = settings_map.find(kSampleId1);
-    EXPECT_TRUE(it1 != settings_map.end());
-    SettingsFlagsAndValue flags_and_value1 = it1->second;
-    EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value1.first);
-    EXPECT_EQ(kSampleValue1, flags_and_value1.second);
-
-    // 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) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   std::unique_ptr<SpdySerializedFrame> go_away(
       spdy_util_.ConstructSpdyGoAway());
   MockRead reads[] = {
       CreateMockRead(*go_away, 1),
   };
@@ skipping 39 matching lines @@
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_THAT(out.rv, IsError(ERR_CONNECTION_CLOSED));
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // HTTP_1_1_REQUIRED results in ERR_HTTP_1_1_REQUIRED.
 TEST_P(SpdyNetworkTransactionTest, HTTP11RequiredError) {
-  // HTTP_1_1_REQUIRED is only supported by HTTP/2.
-  if (spdy_util_.spdy_version() < HTTP2)
-    return;
-
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), nullptr);
 
   std::unique_ptr<SpdySerializedFrame> go_away(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
   MockRead reads[] = {
       CreateMockRead(*go_away, 0),
   };
   SequencedSocketData data(reads, arraysize(reads), nullptr, 0);
 
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsError(ERR_HTTP_1_1_REQUIRED));
 }
 
 // Retry with HTTP/1.1 when receiving HTTP_1_1_REQUIRED.  Note that no actual
 // protocol negotiation happens, instead this test forces protocols for both
 // sockets.
 TEST_P(SpdyNetworkTransactionTest, HTTP11RequiredRetry) {
-  // HTTP_1_1_REQUIRED is only supported by HTTP/2.
-  if (spdy_util_.spdy_version() < HTTP2)
-    return;
-
   HttpRequestInfo request;
   request.method = "GET";
   request.url = default_url_;
   std::unique_ptr<SpdySessionDependencies> session_deps(
       CreateSpdySessionDependencies(GetParam()));
   // Do not force SPDY so that second socket can negotiate HTTP/1.1.
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), std::move(session_deps));
 
   // First socket: HTTP/2 request rejected with HTTP_1_1_REQUIRED.
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   MockWrite writes0[] = {CreateMockWrite(*req, 0)};
   std::unique_ptr<SpdySerializedFrame> go_away(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
   MockRead reads0[] = {CreateMockRead(*go_away, 1)};
   SequencedSocketData data0(reads0, arraysize(reads0), writes0,
                             arraysize(writes0));
 
   std::unique_ptr<SSLSocketDataProvider> ssl_provider0(
       new SSLSocketDataProvider(ASYNC, OK));
   // Expect HTTP/2 protocols too in SSLConfig.
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoHTTP2);
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
   // Force SPDY.
-  ssl_provider0->SetNextProto(GetParam().protocol);
+  ssl_provider0->SetNextProto(kProtoHTTP2);
   helper.AddDataWithSSLSocketDataProvider(&data0, std::move(ssl_provider0));
 
   // Second socket: falling back to HTTP/1.1.
   MockWrite writes1[] = {MockWrite(ASYNC, 0,
                                    "GET / HTTP/1.1\r\n"
                                    "Host: www.example.org\r\n"
                                    "Connection: keep-alive\r\n\r\n")};
   MockRead reads1[] = {MockRead(ASYNC, 1,
                                 "HTTP/1.1 200 OK\r\n"
                                 "Content-Length: 5\r\n\r\n"
@@ skipping 31 matching lines @@
   EXPECT_EQ(443, response->socket_address.port());
   std::string response_data;
   ASSERT_THAT(ReadTransaction(helper.trans(), &response_data), IsOk());
   EXPECT_EQ("hello", response_data);
 }
 
 // Retry with HTTP/1.1 to the proxy when receiving HTTP_1_1_REQUIRED from the
 // proxy.  Note that no actual protocol negotiation happens, instead this test
 // forces protocols for both sockets.
 TEST_P(SpdyNetworkTransactionTest, HTTP11RequiredProxyRetry) {
-  // HTTP_1_1_REQUIRED is only supported by HTTP/2.
-  if (spdy_util_.spdy_version() < HTTP2)
-    return;
-
   HttpRequestInfo request;
   request.method = "GET";
   request.url = default_url_;
   std::unique_ptr<SpdySessionDependencies> session_deps(
       CreateSpdySessionDependencies(
           GetParam(),
           ProxyService::CreateFixedFromPacResult("HTTPS myproxy:70")));
   // Do not force SPDY so that second socket can negotiate HTTP/1.1.
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), std::move(session_deps));
 
   // First socket: HTTP/2 CONNECT rejected with HTTP_1_1_REQUIRED.
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyConnect(
       nullptr, 0, 1, LOWEST, HostPortPair("www.example.org", 443)));
   MockWrite writes0[] = {CreateMockWrite(*req, 0)};
   std::unique_ptr<SpdySerializedFrame> go_away(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
   MockRead reads0[] = {CreateMockRead(*go_away, 1)};
   SequencedSocketData data0(reads0, arraysize(reads0), writes0,
                             arraysize(writes0));
 
   std::unique_ptr<SSLSocketDataProvider> ssl_provider0(
       new SSLSocketDataProvider(ASYNC, OK));
   // Expect HTTP/2 protocols too in SSLConfig.
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoHTTP2);
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
   // Force SPDY.
-  ssl_provider0->SetNextProto(GetParam().protocol);
+  ssl_provider0->SetNextProto(kProtoHTTP2);
   helper.AddDataWithSSLSocketDataProvider(&data0, std::move(ssl_provider0));
 
   // Second socket: retry using HTTP/1.1.
   MockWrite writes1[] = {
       MockWrite(ASYNC, 0,
                 "CONNECT www.example.org:443 HTTP/1.1\r\n"
                 "Host: www.example.org:443\r\n"
                 "Proxy-Connection: keep-alive\r\n\r\n"),
       MockWrite(ASYNC, 2,
                 "GET / HTTP/1.1\r\n"
@@ skipping 173 matching lines @@
                                          PRIVACY_MODE_DISABLED);
   EXPECT_TRUE(HasSpdySession(spdy_session_pool, session_pool_key_direct));
   SpdySessionKey session_pool_key_proxy(
       host_port_pair_,
       ProxyServer::FromURI("www.foo.com", ProxyServer::SCHEME_HTTP),
       PRIVACY_MODE_DISABLED);
   EXPECT_FALSE(HasSpdySession(spdy_session_pool, session_pool_key_proxy));
 
   // New SpdyTestUtil instance for the session that will be used for the
   // proxy connection.
-  SpdyTestUtil spdy_util_2(GetParam().protocol,
-                           GetParam().priority_to_dependency);
+  SpdyTestUtil spdy_util_2(GetParam());
 
   // Set up data for the proxy connection.
   const char kConnect443[] = {
       "CONNECT www.example.org:443 HTTP/1.1\r\n"
       "Host: www.example.org:443\r\n"
       "Proxy-Connection: keep-alive\r\n\r\n"};
   const char kHTTP200[] = {"HTTP/1.1 200 OK\r\n\r\n"};
   std::unique_ptr<SpdySerializedFrame> req2(spdy_util_2.ConstructSpdyGet(
       GetDefaultUrlWithPath("/foo.dat").c_str(), 1, LOWEST));
   std::unique_ptr<SpdySerializedFrame> resp2(
@@ skipping 307 matching lines @@
 
   SpdyHeaderBlock initial_headers;
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
                                  &initial_headers);
   std::unique_ptr<SpdySerializedFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(initial_headers), 2,
                                                1));
 
   SpdyHeaderBlock late_headers;
   late_headers[spdy_util_.GetStatusKey()] = "200";
-  late_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   late_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream2_headers(
       spdy_util_.ConstructSpdyResponseHeaders(2, std::move(late_headers),
                                               false));
 
   std::unique_ptr<SpdySerializedFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   const char kPushedData[] = "pushed";
   std::unique_ptr<SpdySerializedFrame> stream2_body(
@@ skipping 40 matching lines @@
   SpdyHeaderBlock initial_headers;
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
                                  &initial_headers);
   std::unique_ptr<SpdySerializedFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(initial_headers), 2,
                                                1));
   std::unique_ptr<SpdySerializedFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   SpdyHeaderBlock late_headers;
   late_headers[spdy_util_.GetStatusKey()] = "200";
-  late_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   late_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream2_headers(
       spdy_util_.ConstructSpdyResponseHeaders(2, std::move(late_headers),
                                               false));
   const char kPushedData[] = "pushed";
   std::unique_ptr<SpdySerializedFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(2, kPushedData, strlen(kPushedData),
                                         true));
   MockRead reads[] = {
       CreateMockRead(*stream1_reply, 1),   CreateMockRead(*stream2_syn, 2),
@@ skipping 80 matching lines @@
   std::unique_ptr<SpdySerializedFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   std::unique_ptr<SpdySerializedFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
 
   SpdyHeaderBlock initial_headers;
-  if (spdy_util_.spdy_version() < HTTP2) {
-    // In HTTP/2 PUSH_PROMISE headers won't show up in the response headers.
-    initial_headers["alpha"] = "beta";
-  }
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
                                  &initial_headers);
   std::unique_ptr<SpdySerializedFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(initial_headers), 2,
                                                1));
 
   std::unique_ptr<SpdySerializedFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   SpdyHeaderBlock middle_headers;
   middle_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream2_headers1(
       spdy_util_.ConstructSpdyResponseHeaders(2, std::move(middle_headers),
                                               false));
 
   SpdyHeaderBlock late_headers;
   late_headers[spdy_util_.GetStatusKey()] = "200";
-  if (spdy_util_.spdy_version() < HTTP2) {
-    // HTTP/2 eliminates use of the :version header.
-    late_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
-  }
   std::unique_ptr<SpdySerializedFrame> stream2_headers2(
       spdy_util_.ConstructSpdyResponseHeaders(2, std::move(late_headers),
                                               false));
 
   const char kPushedData[] = "pushed";
   std::unique_ptr<SpdySerializedFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(2, kPushedData, strlen(kPushedData),
                                         true));
 
   MockRead reads[] = {
@@ skipping 63 matching lines @@
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers);
   EXPECT_EQ("HTTP/1.1 200", response2.headers->GetStatusLine());
 
   // Verify we got all the headers from all header blocks.
-  if (spdy_util_.spdy_version() < HTTP2)
-    EXPECT_TRUE(response2.headers->HasHeaderValue("alpha", "beta"));
   EXPECT_TRUE(response2.headers->HasHeaderValue("hello", "bye"));
   EXPECT_TRUE(response2.headers->HasHeaderValue("status", "200"));
 
   // Read the final EOF (which will close the session)
   data.Resume();
   base::RunLoop().RunUntilIdle();
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
@@ skipping 190 matching lines @@
       "https://blat.www.example.org/foo.js",  // Cross subdomain
 
       "https://www.example.org/foo.html",
       "https://www.foo.com/foo.js",  // Cross domain
   };
 
   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];
 
-    SpdyTestUtil spdy_test_util(GetParam().protocol,
-                                GetParam().priority_to_dependency);
+    SpdyTestUtil spdy_test_util(GetParam());
     std::unique_ptr<SpdySerializedFrame> stream1_syn(
         spdy_test_util.ConstructSpdyGet(url_to_fetch, 1, LOWEST));
     std::unique_ptr<SpdySerializedFrame> stream1_body(
         spdy_test_util.ConstructSpdyBodyFrame(1, true));
     std::unique_ptr<SpdySerializedFrame> push_rst(
         spdy_test_util.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
     MockWrite writes[] = {
         CreateMockWrite(*stream1_syn, 0), CreateMockWrite(*push_rst, 3),
     };
 
@@ skipping 162 matching lines @@
   EXPECT_EQ(kPushedData, result1);
 }
 
 // Verify that push works cross origin, even if there is already a connection
 // open to origin of pushed resource.
 TEST_P(SpdyNetworkTransactionTest, ServerPushValidCrossOriginWithOpenSession) {
   const char* url_to_fetch0 = "https://mail.example.org/foo";
   const char* url_to_fetch1 = "https://docs.example.org";
   const char* url_to_push = "https://mail.example.org/bar";
 
-  SpdyTestUtil spdy_util_0(GetParam().protocol,
-                           GetParam().priority_to_dependency);
+  SpdyTestUtil spdy_util_0(GetParam());
 
   std::unique_ptr<SpdySerializedFrame> headers0(
       spdy_util_0.ConstructSpdyGet(url_to_fetch0, 1, LOWEST));
   MockWrite writes0[] = {
       CreateMockWrite(*headers0, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> reply0(
       spdy_util_0.ConstructSpdyGetSynReply(nullptr, 0, 1));
   const char kData0[] = "first";
   std::unique_ptr<SpdySerializedFrame> body0(
       spdy_util_0.ConstructSpdyBodyFrame(1, kData0, strlen(kData0), true));
   MockRead reads0[] = {
       CreateMockRead(*reply0, 1),
       CreateMockRead(*body0, 2),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 3)
   };
 
   SequencedSocketData data0(reads0, arraysize(reads0), writes0,
                             arraysize(writes0));
 
-  SpdyTestUtil spdy_util_1(GetParam().protocol,
-                           GetParam().priority_to_dependency);
+  SpdyTestUtil spdy_util_1(GetParam());
 
   std::unique_ptr<SpdySerializedFrame> headers1(
       spdy_util_1.ConstructSpdyGet(url_to_fetch1, 1, LOWEST));
   MockWrite writes1[] = {
       CreateMockWrite(*headers1, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> reply1(
       spdy_util_1.ConstructSpdyGetSynReply(nullptr, 0, 1));
   std::unique_ptr<SpdySerializedFrame> push(
@@ skipping 416 matching lines @@
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
 
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   data.RunUntilPaused();
   base::RunLoop().RunUntilIdle();
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream);
   ASSERT_TRUE(stream->stream());
-  EXPECT_EQ(static_cast<int>(
-                SpdySession::GetDefaultInitialWindowSize(GetParam().protocol)) +
-                kDeltaWindowSize * kDeltaCount -
-                kMaxSpdyFrameChunkSize * kFrameCount,
-            stream->stream()->send_window_size());
+  EXPECT_EQ(
+      static_cast<int>(SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2)) +
+          kDeltaWindowSize * kDeltaCount - kMaxSpdyFrameChunkSize * kFrameCount,
+      stream->stream()->send_window_size());
 
   data.Resume();
   base::RunLoop().RunUntilIdle();
 
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
 
   helper.VerifyDataConsumed();
 }
 
 // Test that received data frames and sent WINDOW_UPDATE frames change
 // the recv_window_size_ correctly.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateSent) {
   const int32_t default_initial_window_size =
-      SpdySession::GetDefaultInitialWindowSize(GetParam().protocol);
+      SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2);
   // Session level maximum window size that is more than twice the default
   // initial window size so that an initial window update is sent.
   const int32_t session_max_recv_window_size = 5 * 64 * 1024;
   ASSERT_LT(2 * default_initial_window_size, session_max_recv_window_size);
   // Stream level maximum window size that is less than the session level
   // maximum window size so that we test for confusion between the two.
   const int32_t stream_max_recv_window_size = 4 * 64 * 1024;
   ASSERT_GT(session_max_recv_window_size, stream_max_recv_window_size);
   // Size of body to be sent.  Has to be less than or equal to both window sizes
   // so that we do not run out of receiving window.  Also has to be greater than
@@ skipping 26 matching lines @@
           kSessionFlowControlStreamId,
           session_max_recv_window_size - default_initial_window_size));
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> session_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(0, session_window_update_delta));
   std::unique_ptr<SpdySerializedFrame> stream_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, stream_window_update_delta));
 
   std::vector<MockWrite> writes;
-  if (GetParam().protocol == kProtoHTTP2) {
-    writes.push_back(MockWrite(ASYNC, kHttp2ConnectionHeaderPrefix,
-                               kHttp2ConnectionHeaderPrefixSize, 0));
-  }
+  writes.push_back(MockWrite(ASYNC, kHttp2ConnectionHeaderPrefix,
+                             kHttp2ConnectionHeaderPrefixSize, 0));
   writes.push_back(CreateMockWrite(*initial_settings_frame, writes.size()));
   writes.push_back(CreateMockWrite(*initial_window_update, writes.size()));
   writes.push_back(CreateMockWrite(*req, writes.size()));
 
   std::vector<MockRead> reads;
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   reads.push_back(CreateMockRead(*resp, writes.size() + reads.size()));
 
   std::vector<std::unique_ptr<SpdySerializedFrame>> body_frames;
@@ skipping 138 matching lines @@
 // writes, save the last, go through before a read could happen.  The last frame
 // ("hello!") is not permitted 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) {
   const int32_t initial_window_size =
-      SpdySession::GetDefaultInitialWindowSize(GetParam().protocol);
+      SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2);
   // Number of upload data buffers we need to send to zero out the window size
   // is the minimal number of upload buffers takes to be bigger than
   // |initial_window_size|.
   size_t num_upload_buffers =
       ceil(static_cast<double>(initial_window_size) / kBufferSize);
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
@@ skipping 128 matching lines @@
 
   data.Resume();  // 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) {
   const int32_t initial_window_size =
-      SpdySession::GetDefaultInitialWindowSize(GetParam().protocol);
+      SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2);
   // Number of upload data buffers we need to send to zero out the window size
   // is the minimal number of upload buffers takes to be bigger than
   // |initial_window_size|.
   size_t num_upload_buffers =
       ceil(static_cast<double>(initial_window_size) / kBufferSize);
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
@@ skipping 145 matching lines @@
   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) {
   const int32_t initial_window_size =
-      SpdySession::GetDefaultInitialWindowSize(GetParam().protocol);
+      SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2);
   // Number of upload data buffers we need to send to zero out the window size
   // is the minimal number of upload buffers takes to be bigger than
   // |initial_window_size|.
   size_t num_upload_buffers =
       ceil(static_cast<double>(initial_window_size) / kBufferSize);
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
@@ skipping 272 matching lines @@
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
   ASSERT_TRUE(out.response_info.headers->HasHeaderValue(kKey, kValue));
 }
 
-class SpdyNetworkTransactionNoTLSUsageCheckTest
-    : public SpdyNetworkTransactionTest {
- protected:
-  void RunNoTLSUsageCheckTest(
-      std::unique_ptr<SSLSocketDataProvider> ssl_provider) {
-    // Construct the request.
-    std::unique_ptr<SpdySerializedFrame> req(
-        spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-    MockWrite writes[] = {CreateMockWrite(*req, 0)};
-
-    std::unique_ptr<SpdySerializedFrame> resp(
-        spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-    std::unique_ptr<SpdySerializedFrame> body(
-        spdy_util_.ConstructSpdyBodyFrame(1, true));
-    MockRead reads[] = {
-        CreateMockRead(*resp, 1),
-        CreateMockRead(*body, 2),
-        MockRead(ASYNC, 0, 3)  // EOF
-    };
-
-    SequencedSocketData data(reads, arraysize(reads), writes,
-                             arraysize(writes));
-    HttpRequestInfo request;
-    request.method = "GET";
-    request.url = default_url_;
-    NormalSpdyTransactionHelper helper(
-        request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
-    helper.RunToCompletionWithSSLData(&data, std::move(ssl_provider));
-    TransactionHelperResult out = helper.output();
-    EXPECT_THAT(out.rv, IsOk());
-    EXPECT_EQ("HTTP/1.1 200", out.status_line);
-    EXPECT_EQ("hello!", out.response_data);
-  }
-};
-
-INSTANTIATE_TEST_CASE_P(
-    Spdy,
-    SpdyNetworkTransactionNoTLSUsageCheckTest,
-    ::testing::Values(SpdyNetworkTransactionTestParams(kProtoSPDY31,
-                                                       false)));
-
-TEST_P(SpdyNetworkTransactionNoTLSUsageCheckTest, TLSVersionTooOld) {
-  std::unique_ptr<SSLSocketDataProvider> ssl_provider(
-      new SSLSocketDataProvider(ASYNC, OK));
-  SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_SSL3,
-                                &ssl_provider->connection_status);
-
-  RunNoTLSUsageCheckTest(std::move(ssl_provider));
-}
-
-TEST_P(SpdyNetworkTransactionNoTLSUsageCheckTest, TLSCipherSuiteSucky) {
-  std::unique_ptr<SSLSocketDataProvider> ssl_provider(
-      new SSLSocketDataProvider(ASYNC, OK));
-  // Set to TLS_RSA_WITH_NULL_MD5
-  SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
-
-  RunNoTLSUsageCheckTest(std::move(ssl_provider));
-}
-
 class SpdyNetworkTransactionTLSUsageCheckTest
     : public SpdyNetworkTransactionTest {
  protected:
   void RunTLSUsageCheckTest(
       std::unique_ptr<SSLSocketDataProvider> ssl_provider) {
     std::unique_ptr<SpdySerializedFrame> goaway(
         spdy_util_.ConstructSpdyGoAway(0, GOAWAY_INADEQUATE_SECURITY, ""));
     MockWrite writes[] = {CreateMockWrite(*goaway)};
 
     StaticSocketDataProvider data(NULL, 0, writes, arraysize(writes));
     HttpRequestInfo request;
     request.method = "GET";
     request.url = default_url_;
     NormalSpdyTransactionHelper helper(
         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletionWithSSLData(&data, std::move(ssl_provider));
     TransactionHelperResult out = helper.output();
     EXPECT_THAT(out.rv, IsError(ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY));
   }
 };
 
-INSTANTIATE_TEST_CASE_P(
-    Spdy,
-    SpdyNetworkTransactionTLSUsageCheckTest,
-    ::testing::Values(SpdyNetworkTransactionTestParams(kProtoHTTP2, false),
-                      SpdyNetworkTransactionTestParams(kProtoHTTP2, true)));
+INSTANTIATE_TEST_CASE_P(Spdy,
+                        SpdyNetworkTransactionTLSUsageCheckTest,
+                        ::testing::Bool());
 
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSVersionTooOld) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_SSL3,
                                 &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net