Disable SPDY/3.1.

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 115 matching lines @@
 const base::string16 kBaz(ASCIIToUTF16("baz"));
 const base::string16 kFirst(ASCIIToUTF16("first"));
 const base::string16 kFoo(ASCIIToUTF16("foo"));
 const base::string16 kFoo2(ASCIIToUTF16("foo2"));
 const base::string16 kFoo3(ASCIIToUTF16("foo3"));
 const base::string16 kFou(ASCIIToUTF16("fou"));
 const base::string16 kSecond(ASCIIToUTF16("second"));
 const base::string16 kTestingNTLM(ASCIIToUTF16("testing-ntlm"));
 const base::string16 kWrongPassword(ASCIIToUTF16("wrongpassword"));
 
+const char kAlternativeServiceHttpHeader[] =
+    "Alt-Svc: npn-h2=\"mail.example.org:443\"\r\n";

[Ryan Hamilton, 2016/07/06 19:24:58]

Is "npn-h2" the right header?

[Bence, 2016/07/07 16:20:41]

I was wondering about the same.  Filed https://crbug.com/626375, and working on
the fix.

+
 int GetIdleSocketCountInTransportSocketPool(HttpNetworkSession* session) {
   return session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)
       ->IdleSocketCount();
 }
 
 int GetIdleSocketCountInSSLSocketPool(HttpNetworkSession* session) {
   return session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)
       ->IdleSocketCount();
 }
 
@@ skipping 173 matching lines @@
   }
 
   NextProto GetProtocol() const {
     return GetParam() == kTestCaseSPDY31 ? kProtoSPDY31 : kProtoHTTP2;
   }
 
   bool GetDependenciesFromPriority() const {
     return GetParam() == kTestCaseHTTP2PriorityDependencies;
   }
 
-  const char* GetAlternateProtocolFromParam() {
-    return AlternateProtocolToString(
-        AlternateProtocolFromNextProto(GetProtocol()));
-  }
-
-  std::string GetAlternativeServiceHttpHeader() {
-    return std::string("Alt-Svc: ") + GetAlternateProtocolFromParam() +
-           "=\"mail.example.org:443\"\r\n";
-  }
-
   // Either |write_failure| specifies a write failure or |read_failure|
   // specifies a read failure when using a reused socket.  In either case, the
   // failure should cause the network transaction to resend the request, and the
   // other argument should be NULL.
   void KeepAliveConnectionResendRequestTest(const MockWrite* write_failure,
                                             const MockRead* read_failure);
 
   // Either |write_failure| specifies a write failure or |read_failure|
   // specifies a read failure when using a reused socket.  In either case, the
   // failure should cause the network transaction to resend the request, and the
@@ skipping 9591 matching lines @@
       AuthCredentials(kFirst, kBar), callback4.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback4.WaitForResult();
   EXPECT_THAT(rv, IsOk());
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   EXPECT_FALSE(response->auth_challenge);
 }
 
 TEST_P(HttpNetworkTransactionTest, HonorAlternativeServiceHeader) {
-  std::string alternative_service_http_header =
-      GetAlternativeServiceHttpHeader();
+  // SPDY/3.1 is not supported.
+  if (GetProtocol() != kProtoHTTP2) {
+    return;
+  }
 
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternative_service_http_header.c_str()),
+      MockRead(kAlternativeServiceHttpHeader),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, OK),
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
   request.load_flags = 0;
 
@@ skipping 37 matching lines @@
   ASSERT_EQ(1u, alternative_service_vector.size());
   EXPECT_EQ(AlternateProtocolFromNextProto(GetProtocol()),
             alternative_service_vector[0].protocol);
   EXPECT_EQ("mail.example.org", alternative_service_vector[0].host);
   EXPECT_EQ(443, alternative_service_vector[0].port);
 }
 
 // Regression test for https://crbug.com/615497.
 TEST_P(HttpNetworkTransactionTest,
        DoNotParseAlternativeServiceHeaderOnInsecureRequest) {
-  std::string alternative_service_http_header =
-      GetAlternativeServiceHttpHeader();
-
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternative_service_http_header.c_str()),
+      MockRead(kAlternativeServiceHttpHeader),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, OK),
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   request.load_flags = 0;
 
@@ skipping 173 matching lines @@
   std::string response_data;
   ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
   EXPECT_EQ("hello world", response_data);
 
   alternative_service_vector =
       http_server_properties->GetAlternativeServices(test_server);
   EXPECT_TRUE(alternative_service_vector.empty());
 }
 
 TEST_P(HttpNetworkTransactionTest, HonorMultipleAlternativeServiceHeaders) {
+  // SPDY/3.1 is not supported.
+  if (GetProtocol() != kProtoHTTP2) {
+    return;
+  }
+
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead("Alt-Svc: "),
-      MockRead(GetAlternateProtocolFromParam()),
-      MockRead("=\"www.example.com:443\","),
-      MockRead(GetAlternateProtocolFromParam()),
-      MockRead("=\":1234\"\r\n\r\n"),
+      MockRead("Alt-Svc: npn-h2=\"www.example.com:443\","),
+      MockRead("npn-h2=\":1234\"\r\n\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, OK),
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
   request.load_flags = 0;
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
@@ skipping 553 matching lines @@
   ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
   EXPECT_EQ("hello world", response_data);
 }
 
 TEST_P(HttpNetworkTransactionTest, UseAlternateProtocolForNpnSpdy) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
   request.load_flags = 0;
 
-  std::string alternative_service_http_header =
-      GetAlternativeServiceHttpHeader();
-
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternative_service_http_header.c_str()),
+      MockRead(kAlternativeServiceHttpHeader),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
   SSLSocketDataProvider ssl_http11(ASYNC, OK);
   ssl_http11.SetNextProto(kProtoHTTP11);
@@ skipping 60 matching lines @@
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
   ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
   EXPECT_EQ("hello!", response_data);
 }
 
 TEST_P(HttpNetworkTransactionTest, AlternateProtocolWithSpdyLateBinding) {
+  // SPDY/3.1 is not supported.
+  if (GetProtocol() != kProtoHTTP2) {
+    return;
+  }
+
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
   request.load_flags = 0;
 
   // First transaction receives Alt-Svc header over HTTP/1.1.
-  std::string alternative_service_http_header =
-      GetAlternativeServiceHttpHeader();
-
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternative_service_http_header.c_str()),
+      MockRead(kAlternativeServiceHttpHeader),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider http11_data(data_reads, arraysize(data_reads), NULL,
                                        0);
   session_deps_.socket_factory->AddSocketDataProvider(&http11_data);
 
@@ skipping 95 matching lines @@
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_THAT(ReadTransaction(&trans3, &response_data), IsOk());
   EXPECT_EQ("hello!", response_data);
 }
 
 TEST_P(HttpNetworkTransactionTest, StallAlternativeServiceForNpnSpdy) {
+  // SPDY/3.1 is not supported.
+  if (GetProtocol() != kProtoHTTP2) {
+    return;
+  }
+
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
   request.load_flags = 0;
 
-  std::string alternative_service_http_header =
-      GetAlternativeServiceHttpHeader();
-
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternative_service_http_header.c_str()),
+      MockRead(kAlternativeServiceHttpHeader),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
 
@@ skipping 112 matching lines @@
           new CapturingProxyResolverFactory(&capturing_proxy_resolver)),
       NULL));
   TestNetLog net_log;
   session_deps_.net_log = &net_log;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
   request.load_flags = 0;
 
-  std::string alternative_service_http_header =
-      GetAlternativeServiceHttpHeader();
-
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternative_service_http_header.c_str()),
+      MockRead(kAlternativeServiceHttpHeader),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
   SSLSocketDataProvider ssl_http11(ASYNC, OK);
@@ skipping 88 matching lines @@
                                  CONNECT_TIMING_HAS_SSL_TIMES);
 }
 
 TEST_P(HttpNetworkTransactionTest,
        UseAlternativeServiceForNpnSpdyWithExistingSpdySession) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
   request.load_flags = 0;
 
-  std::string alternative_service_http_header =
-      GetAlternativeServiceHttpHeader();
-
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternative_service_http_header.c_str()),
+      MockRead(kAlternativeServiceHttpHeader),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
   SSLSocketDataProvider ssl_http11(ASYNC, OK);
   ssl_http11.SetNextProto(kProtoHTTP11);
@@ skipping 685 matching lines @@
   request.url = GURL("https://www.example.org/");
   request.load_flags = 0;
 
   MockWrite data_writes[] = {
       MockWrite(
           "GET / HTTP/1.1\r\n"
           "Host: www.example.org\r\n"
           "Connection: keep-alive\r\n\r\n"),
   };
 
-  std::string alternative_service_http_header =
-      GetAlternativeServiceHttpHeader();
-
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternative_service_http_header.c_str()),
+      MockRead(kAlternativeServiceHttpHeader),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, OK),
   };
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(kProtoHTTP11);
 
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
@@ skipping 3880 matching lines @@
   session_deps_.enable_npn = true;
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   HttpRequestInfo request;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             trans.Start(&request, callback.callback(), BoundNetLog()));
 
   EXPECT_THAT(trans.server_ssl_config_.alpn_protos,
-              testing::ElementsAre(kProtoHTTP2, kProtoSPDY31, kProtoHTTP11));
+              testing::ElementsAre(kProtoHTTP2, kProtoHTTP11));
   EXPECT_THAT(trans.server_ssl_config_.npn_protos,
-              testing::ElementsAre(kProtoHTTP2, kProtoSPDY31, kProtoHTTP11));
+              testing::ElementsAre(kProtoHTTP2, kProtoHTTP11));
 }
 
 TEST_P(HttpNetworkTransactionTest, DisableNPN) {
   session_deps_.enable_npn = false;
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   HttpRequestInfo request;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             trans.Start(&request, callback.callback(), BoundNetLog()));
 
   EXPECT_THAT(trans.server_ssl_config_.alpn_protos,
-              testing::ElementsAre(kProtoHTTP2, kProtoSPDY31, kProtoHTTP11));
+              testing::ElementsAre(kProtoHTTP2, kProtoHTTP11));
   EXPECT_TRUE(trans.server_ssl_config_.npn_protos.empty());
 }
 
 #if !defined(OS_IOS)
 TEST_P(HttpNetworkTransactionTest, TokenBindingSpdy) {
   const std::string https_url = "https://www.example.com";
   HttpRequestInfo request;
   request.url = GURL(https_url);
   request.method = "GET";
 
@@ skipping 22 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy);
   HttpRequestHeaders headers;
   ASSERT_TRUE(trans.GetFullRequestHeaders(&headers));
   EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding));
 }
 #endif  // !defined(OS_IOS)
 
 }  // namespace net