Remove SpdyNetworkTransactionTestSSLType.

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 43 matching lines @@
 
 namespace net {
 
 namespace {
 
 using testing::Each;
 using testing::Eq;
 
 const int32_t kBufferSize = SpdyHttpStream::kRequestBodyBufferSize;
 
-enum SpdyNetworkTransactionTestSSLType {
-  // Request an https:// URL and use NPN (or ALPN) to negotiate SPDY during
-  // the TLS handshake.
-  HTTPS_SPDY_VIA_NPN,
-  // Request an https:// URL to a server that supports SPDY via Alternative
-  // Service.
-  // See: http://httpwg.org/http-extensions/alt-svc.html.
-  HTTPS_SPDY_VIA_ALT_SVC,
-};
-
 struct SpdyNetworkTransactionTestParams {
   SpdyNetworkTransactionTestParams()
       : protocol(kProtoSPDY31),
-        ssl_type(HTTPS_SPDY_VIA_NPN),
         priority_to_dependency(false) {}
 
   SpdyNetworkTransactionTestParams(NextProto protocol,
-                                   SpdyNetworkTransactionTestSSLType ssl_type,
                                    bool priority_to_dependency)
       : protocol(protocol),
-        ssl_type(ssl_type),
         priority_to_dependency(priority_to_dependency) {}
 
   friend std::ostream& operator<<(std::ostream& os,
                                   const SpdyNetworkTransactionTestParams& p) {
-    std::string type_str;
-    switch (p.ssl_type) {
-      case HTTPS_SPDY_VIA_ALT_SVC:
-        type_str = "HTTPS_SPDY_VIA_ALT_SVC";
-        break;
-      case HTTPS_SPDY_VIA_NPN:
-        type_str = "HTTPS_SPDY_VIA_NPN";
-        break;
-    }
     os << "{ protocol: " << SSLClientSocket::NextProtoToString(p.protocol)
-       << ", ssl_type: " << type_str
        << ", priority_to_dependency: " << p.priority_to_dependency << " }";
     return os;
   }
 
   NextProto protocol;
-  SpdyNetworkTransactionTestSSLType ssl_type;
   bool priority_to_dependency;
 };
 
 void UpdateSpdySessionDependencies(SpdyNetworkTransactionTestParams test_params,
                                    SpdySessionDependencies* session_deps) {
-  if (test_params.ssl_type == HTTPS_SPDY_VIA_ALT_SVC) {
-    base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-    session_deps->http_server_properties->SetAlternativeService(
-        url::SchemeHostPort(GURL(kDefaultUrl)),
-        AlternativeService(AlternateProtocolFromNextProto(test_params.protocol),
-                           "mail.example.org", 443),
-        expiration);
-  }
   session_deps->enable_priority_dependencies =
       test_params.priority_to_dependency;
 }
 
 std::unique_ptr<SpdySessionDependencies> CreateSpdySessionDependencies(
     SpdyNetworkTransactionTestParams test_params) {
   std::unique_ptr<SpdySessionDependencies> session_deps(
       new SpdySessionDependencies(test_params.protocol));
   UpdateSpdySessionDependencies(test_params, session_deps.get());
   return session_deps;
@@ skipping 201 matching lines @@
       if (ssl_provider->next_proto_status ==
           SSLClientSocket::kNextProtoUnsupported) {
         ssl_provider->SetNextProto(test_params_.protocol);
       }
 
       session_deps_->socket_factory->AddSSLSocketDataProvider(
           ssl_provider.get());
       ssl_vector_.push_back(std::move(ssl_provider));
 
       session_deps_->socket_factory->AddSocketDataProvider(data);
-      if (test_params_.ssl_type == HTTPS_SPDY_VIA_ALT_SVC) {
-        MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
-        std::unique_ptr<StaticSocketDataProvider> hanging_non_alt_svc_socket(
-            base::WrapUnique(new StaticSocketDataProvider(NULL, 0, NULL, 0)));
-        hanging_non_alt_svc_socket->set_connect_data(hanging_connect);
-        session_deps_->socket_factory->AddSocketDataProvider(
-            hanging_non_alt_svc_socket.get());
-        alternate_vector_.push_back(std::move(hanging_non_alt_svc_socket));
-      }
     }
 
     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(); }
@@ skipping 314 matching lines @@
 
 //-----------------------------------------------------------------------------
 // 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,
-                                         HTTPS_SPDY_VIA_NPN,
-                                         false),
-        SpdyNetworkTransactionTestParams(kProtoSPDY31,
-                                         HTTPS_SPDY_VIA_ALT_SVC,
-                                         false),
-        SpdyNetworkTransactionTestParams(kProtoHTTP2,
-                                         HTTPS_SPDY_VIA_NPN,
-                                         false),
-        SpdyNetworkTransactionTestParams(kProtoHTTP2, HTTPS_SPDY_VIA_NPN, true),
-        SpdyNetworkTransactionTestParams(kProtoHTTP2,
-                                         HTTPS_SPDY_VIA_ALT_SVC,
-                                         false),
-        SpdyNetworkTransactionTestParams(kProtoHTTP2,
-                                         HTTPS_SPDY_VIA_ALT_SVC,
-                                         true)));
+    ::testing::Values(SpdyNetworkTransactionTestParams(kProtoSPDY31, false),
+                      SpdyNetworkTransactionTestParams(kProtoSPDY31, true),
+                      SpdyNetworkTransactionTestParams(kProtoHTTP2, false),
+                      SpdyNetworkTransactionTestParams(kProtoHTTP2, true)));
 
 // 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 1602 matching lines @@
   helper.ResetTrans();
   base::RunLoop().RunUntilIdle();
 
   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().ssl_type != HTTPS_SPDY_VIA_NPN)
-    return;
-
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req)};
   MockWrite writes2[] = {CreateMockWrite(*req, 0)};
 
   // 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_t kGetBodyFrame2[] = {
       0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00,
@@ skipping 2168 matching lines @@
   EXPECT_EQ(ERR_HTTP_1_1_REQUIRED, out.rv);
 }
 
 // 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;
-  // HTTP_1_1_REQUIRED implementation relies on the assumption that HTTP/2 is
-  // only spoken over SSL.
-  if (GetParam().ssl_type != HTTPS_SPDY_VIA_NPN)
-    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));
 
@@ skipping 63 matching lines @@
   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;
-  // HTTP_1_1_REQUIRED implementation relies on the assumption that HTTP/2 is
-  // only spoken over SSL.
-  if (GetParam().ssl_type != HTTPS_SPDY_VIA_NPN)
-    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(),
@@ skipping 278 matching lines @@
   EXPECT_EQ("hello!", response_data);
 
   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().ssl_type != HTTPS_SPDY_VIA_NPN)
-    return;
   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, ERR_IO_PENDING, 3),
       MockRead(ASYNC, ERR_CONNECTION_RESET, 4),
   };
@@ skipping 691 matching lines @@
 
   SequencedSocketData data(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) {
-  // Running these tests via Alt-Svc is too complicated to be worthwhile.
-  if (GetParam().ssl_type != HTTPS_SPDY_VIA_NPN)
-    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[] = {
       "https://www.example.org/foo.html",
       "http://www.example.org/foo.js",  // Bad protocol
@@ skipping 185 matching lines @@
   EXPECT_EQ("HTTP/1.1 200", push_response.headers->GetStatusLine());
 
   std::string result1;
   ReadResult(trans1.get(), &result1);
   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) {
-  // Running this test via Alt-Svc is too complicated to be worthwhile.
-  if (GetParam().ssl_type != HTTPS_SPDY_VIA_NPN)
-    return;
-
   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);
 
   std::unique_ptr<SpdySerializedFrame> headers0(
       spdy_util_0.ConstructSpdyGet(url_to_fetch0, 1, LOWEST));
   MockWrite writes0[] = {
@@ skipping 1316 matching lines @@
     NormalSpdyTransactionHelper helper(
         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletionWithSSLData(&data, std::move(ssl_provider));
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(OK, out.rv);
     EXPECT_EQ("HTTP/1.1 200", out.status_line);
     EXPECT_EQ("hello!", out.response_data);
   }
 };
 
-//-----------------------------------------------------------------------------
-// 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,
     SpdyNetworkTransactionNoTLSUsageCheckTest,
     ::testing::Values(SpdyNetworkTransactionTestParams(kProtoSPDY31,
-                                                       HTTPS_SPDY_VIA_NPN,
                                                        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));
 }
@@ skipping 24 matching lines @@
         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletionWithSSLData(&data, std::move(ssl_provider));
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY, out.rv);
   }
 };
 
 INSTANTIATE_TEST_CASE_P(
     Spdy,
     SpdyNetworkTransactionTLSUsageCheckTest,
-    ::testing::Values(SpdyNetworkTransactionTestParams(kProtoHTTP2,
-                                                       HTTPS_SPDY_VIA_NPN,
-                                                       false),
-                      SpdyNetworkTransactionTestParams(kProtoHTTP2,
-                                                       HTTPS_SPDY_VIA_NPN,
-                                                       true)));
+    ::testing::Values(SpdyNetworkTransactionTestParams(kProtoHTTP2, false),
+                      SpdyNetworkTransactionTestParams(kProtoHTTP2, true)));
 
 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