Remove SPDY/3.1 tests.

net/http/http_proxy_client_socket_pool_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 "net/http/http_proxy_client_socket_pool.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 29 matching lines @@
 };
 const int kAuthHeadersSize = arraysize(kAuthHeaders) / 2;
 
 enum HttpProxyType {
   HTTP,
   HTTPS,
   SPDY
 };
 
 struct HttpProxyClientSocketPoolTestParams {
-  HttpProxyClientSocketPoolTestParams()
-      : proxy_type(HTTP),
-        protocol(kProtoSPDY31),
-        priority_to_dependency(false) {}
-
   HttpProxyClientSocketPoolTestParams(HttpProxyType proxy_type,
-                                      NextProto protocol,
                                       bool priority_to_dependency)
       : proxy_type(proxy_type),
-        protocol(protocol),
         priority_to_dependency(priority_to_dependency) {}
 
   HttpProxyType proxy_type;
-  NextProto protocol;
   bool priority_to_dependency;
 };
 
 typedef ::testing::TestWithParam<HttpProxyType> TestWithHttpParam;
 
 const char kHttpProxyHost[] = "httpproxy.example.com";
 const char kHttpsProxyHost[] = "httpsproxy.example.com";
 
 }  // namespace
 
 class HttpProxyClientSocketPoolTest
     : public ::testing::TestWithParam<HttpProxyClientSocketPoolTestParams> {
  protected:
   HttpProxyClientSocketPoolTest()
-      : session_deps_(GetParam().protocol),
-        transport_socket_pool_(kMaxSockets,
+      : transport_socket_pool_(kMaxSockets,
                                kMaxSocketsPerGroup,
                                session_deps_.socket_factory.get()),
         ssl_socket_pool_(kMaxSockets,
                          kMaxSocketsPerGroup,
                          session_deps_.cert_verifier.get(),
                          NULL /* channel_id_store */,
                          NULL /* transport_security_state */,
                          NULL /* cert_transparency_verifier */,
                          NULL /* ct_policy_enforcer */,
                          std::string() /* ssl_session_cache_shard */,
                          session_deps_.socket_factory.get(),
                          &transport_socket_pool_,
                          NULL,
                          NULL,
                          session_deps_.ssl_config_service.get(),
                          BoundNetLog().net_log()),
-        spdy_util_(GetParam().protocol, GetParam().priority_to_dependency),
+        spdy_util_(GetParam().priority_to_dependency),
         pool_(kMaxSockets,
               kMaxSocketsPerGroup,
               &transport_socket_pool_,
               &ssl_socket_pool_,
               NULL) {
     session_deps_.enable_priority_dependencies =
         GetParam().priority_to_dependency;
     session_ = CreateNetworkSession();
   }
 
@@ skipping 90 matching lines @@
 
     if (GetParam().proxy_type != HTTP) {
       ssl_data_.reset(new SSLSocketDataProvider(SYNCHRONOUS, OK));
       if (GetParam().proxy_type == SPDY) {
         InitializeSpdySsl();
       }
       socket_factory()->AddSSLSocketDataProvider(ssl_data_.get());
     }
   }
 
-  void InitializeSpdySsl() {
-    ssl_data_->SetNextProto(GetParam().protocol);
-  }
+  void InitializeSpdySsl() { ssl_data_->SetNextProto(kProtoHTTP2); }
 
   std::unique_ptr<HttpNetworkSession> CreateNetworkSession() {
     return SpdySessionDependencies::SpdyCreateSession(&session_deps_);
   }
 
   RequestPriority GetLastTransportRequestPriority() const {
     return transport_socket_pool_.last_request_priority();
   }
 
  private:
@@ skipping 17 matching lines @@
 
 //-----------------------------------------------------------------------------
 // All tests are run with three different proxy types: HTTP, HTTPS (non-SPDY)
 // and SPDY.
 //
 // TODO(akalin): Use ::testing::Combine() when we are able to use
 // <tr1/tuple>.
 INSTANTIATE_TEST_CASE_P(
     HttpProxyClientSocketPoolTests,
     HttpProxyClientSocketPoolTest,
-    ::testing::Values(
-        HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY31, false),
-        HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY31, false),
-        HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY31, false),
-        HttpProxyClientSocketPoolTestParams(HTTP, kProtoHTTP2, false),
-        HttpProxyClientSocketPoolTestParams(HTTP, kProtoHTTP2, true),
-        HttpProxyClientSocketPoolTestParams(HTTPS, kProtoHTTP2, false),
-        HttpProxyClientSocketPoolTestParams(HTTPS, kProtoHTTP2, true),
-        HttpProxyClientSocketPoolTestParams(SPDY, kProtoHTTP2, false),
-        HttpProxyClientSocketPoolTestParams(SPDY, kProtoHTTP2, true)));
+    ::testing::Values(HttpProxyClientSocketPoolTestParams(HTTP, false),
+                      HttpProxyClientSocketPoolTestParams(HTTP, true),
+                      HttpProxyClientSocketPoolTestParams(HTTPS, false),
+                      HttpProxyClientSocketPoolTestParams(HTTPS, true),
+                      HttpProxyClientSocketPoolTestParams(SPDY, false),
+                      HttpProxyClientSocketPoolTestParams(SPDY, true)));
 
 TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) {
   Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 
   std::unique_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate());
   int rv = handle_.Init("a", CreateNoTunnelParams(proxy_delegate.get()), LOW,
                         ClientSocketPool::RespectLimits::ENABLED,
                         CompletionCallback(), &pool_, BoundNetLog());
   EXPECT_THAT(rv, IsOk());
   EXPECT_TRUE(handle_.is_initialized());
@@ skipping 32 matching lines @@
       NULL, 0, 1, LOW, HostPortPair("www.google.com", 443)));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*req, 0, ASYNC),
     CreateMockWrite(*rst, 2, ASYNC),
   };
   SpdyHeaderBlock resp_block;
   resp_block[spdy_util_.GetStatusKey()] = "407";
   resp_block["proxy-authenticate"] = "Basic realm=\"MyRealm1\"";
-  spdy_util_.MaybeAddVersionHeader(&resp_block);
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyReply(1, std::move(resp_block)));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 3)
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
@@ skipping 431 matching lines @@
     // Make sure Location header was included and correct.
     std::string location;
     EXPECT_TRUE(headers->IsRedirect(&location));
     EXPECT_EQ(location, redirectTarget);
   }
 }
 
 // It would be nice to also test the timeouts in HttpProxyClientSocketPool.
 
 }  // namespace net