Remove SPDY/3.1 tests.

net/http/http_stream_factory_impl_job_controller_unittest.cc

 // Copyright (c) 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_stream_factory_impl_job_controller.h"
 
 #include <memory>
 
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_stream_factory_impl_request.h"
@@ skipping 16 matching lines @@
   delete stream;
 }
 
 }  // anonymous namespace
 
 class HttpStreamFactoryImplJobControllerTest
     : public ::testing::Test,
       public ::testing::WithParamInterface<NextProto> {
  public:
   HttpStreamFactoryImplJobControllerTest()
-      : session_deps_(GetParam(), ProxyService::CreateDirect()) {
+      : session_deps_(ProxyService::CreateDirect()) {
     session_deps_.enable_quic = true;
     session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
     factory_ =
         static_cast<HttpStreamFactoryImpl*>(session_->http_stream_factory());
     job_controller_ = new HttpStreamFactoryImpl::JobController(
         factory_, &request_delegate_, session_.get(), &job_factory_);
     HttpStreamFactoryImplPeer::AddJobController(factory_, job_controller_);
   }
 
   ~HttpStreamFactoryImplJobControllerTest() {}
@@ skipping 11 matching lines @@
   MockHttpStreamRequestDelegate request_delegate_;
   SpdySessionDependencies session_deps_;
   std::unique_ptr<HttpNetworkSession> session_;
   HttpStreamFactoryImpl* factory_;
   HttpStreamFactoryImpl::JobController* job_controller_;
   std::unique_ptr<HttpStreamFactoryImpl::Request> request_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpStreamFactoryImplJobControllerTest);
 };
 
-INSTANTIATE_TEST_CASE_P(NextProto,
-                        HttpStreamFactoryImplJobControllerTest,
-                        testing::Values(kProtoSPDY31, kProtoHTTP2));
-
-TEST_P(HttpStreamFactoryImplJobControllerTest,
+TEST_F(HttpStreamFactoryImplJobControllerTest,
        OnStreamFailedWithNoAlternativeJob) {
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
                              BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
 
   EXPECT_TRUE(job_controller_->main_job());
 
   // There's no other alternative job. Thus when stream failed, it should
   // notify Request of the stream failure.
   EXPECT_CALL(request_delegate_, OnStreamFailed(ERR_FAILED, _)).Times(1);
   job_controller_->OnStreamFailed(job_factory_.main_job(), ERR_FAILED,
                                   SSLConfig());
 }
 
-TEST_P(HttpStreamFactoryImplJobControllerTest,
+TEST_F(HttpStreamFactoryImplJobControllerTest,
        OnStreamReadyWithNoAlternativeJob) {
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
                              BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
 
   // There's no other alternative job. Thus when stream is ready, it should
   // notify Request.
   HttpStream* http_stream =
       new HttpBasicStream(new ClientSocketHandle(), false);
   job_factory_.main_job()->SetStream(http_stream);
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, http_stream))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
   job_controller_->OnStreamReady(job_factory_.main_job(), SSLConfig(),
                                  ProxyInfo());
 }
 
 // Test we cancel Jobs correctly when the Request is explicitly canceled
 // before any Job is bound to Request.
-TEST_P(HttpStreamFactoryImplJobControllerTest, CancelJobsBeforeBinding) {
+TEST_F(HttpStreamFactoryImplJobControllerTest, CancelJobsBeforeBinding) {
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
                              BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // Reset the Request will cancel all the Jobs since there's no Job determined
   // to serve Request yet and JobController will notify the factory to delete
   // itself upon completion.
   request_.reset();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
-TEST_P(HttpStreamFactoryImplJobControllerTest, OnStreamFailedForBothJobs) {
+TEST_F(HttpStreamFactoryImplJobControllerTest, OnStreamFailedForBothJobs) {
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
@@ skipping 12 matching lines @@
   EXPECT_TRUE(!job_controller_->alternative_job());
   EXPECT_TRUE(job_controller_->main_job());
 
   // The failure of second Job should be reported to Request as there's no more
   // pending Job to serve the Request.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(1);
   job_controller_->OnStreamFailed(job_factory_.main_job(), ERR_FAILED,
                                   SSLConfig());
 }
 
-TEST_P(HttpStreamFactoryImplJobControllerTest,
+TEST_F(HttpStreamFactoryImplJobControllerTest,
        SecondJobFailsAfterFirstJobSucceeds) {
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
@@ skipping 21 matching lines @@
   // is already successfully served.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
   job_controller_->OnStreamFailed(job_factory_.alternative_job(), ERR_FAILED,
                                   SSLConfig());
 
   // Reset the request as it's been successfully served.
   request_.reset();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
-TEST_P(HttpStreamFactoryImplJobControllerTest,
+TEST_F(HttpStreamFactoryImplJobControllerTest,
        SecondJobSucceedsAfterFirstJobFailed) {
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
@@ skipping 18 matching lines @@
   job_factory_.alternative_job()->SetStream(http_stream);
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, http_stream))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
   job_controller_->OnStreamReady(job_factory_.alternative_job(), SSLConfig(),
                                  ProxyInfo());
 }
 
 // Regression test for crbug/621069.
 // Get load state after main job fails and before alternative job succeeds.
-TEST_P(HttpStreamFactoryImplJobControllerTest, GetLoadStateAfterMainJobFailed) {
+TEST_F(HttpStreamFactoryImplJobControllerTest, GetLoadStateAfterMainJobFailed) {
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(QUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
@@ skipping 19 matching lines @@
       new HttpBasicStream(new ClientSocketHandle(), false);
   job_factory_.alternative_job()->SetStream(http_stream);
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, http_stream))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
   job_controller_->OnStreamReady(job_factory_.alternative_job(), SSLConfig(),
                                  ProxyInfo());
 }
 
 }  // namespace net