SPDY - disable spdy/2.1 (flow control) by default

net/http/http_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 "net/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 255 matching lines @@
   const int num_rows = static_cast<int>(
       ceil(static_cast<float>(size) / sizeof_row));
   const int sizeof_data = num_rows * sizeof_row;
   DCHECK(sizeof_data >= size);
   str->reserve(sizeof_data);
 
   for (int i = 0; i < num_rows; ++i)
     str->append(row, sizeof_row);
 }
 
+void SetAlternateProtocol(
+    HttpServerProperties* http_server_properties,
+    const HostPortPair& server,
+    uint16 alternate_port,
+    AlternateProtocol alternate_protocol) {
+  http_server_properties->SetAlternateProtocol(
+      server, alternate_port, alternate_protocol);
+  HttpStreamFactory::set_highest_supported_alternate_protocol(

[willchan no longer on Chromium, 2012/02/29 20:15:27]

Using a global like this messes up the test dependencies. What if tests executed
in a different order? Nothing is undoing this global mutation. You should
probably scope this somehow.

Also note that in general I prefer not using globals like this. I'm fine in this
case, because theoretically we're going to kill off support for old versions in
the not too distant future. If we had to support this long-term, I'd ask you to
do the work to pass the parameters into the constructor.

[ramant (doing other things), 2012/03/01 03:51:59]

Done.

+      alternate_protocol);
+}
+
 // Alternative functions that eliminate randomness and dependency on the local
 // host name so that the generated NTLM messages are reproducible.
 void MockGenerateRandom1(uint8* output, size_t n) {
   static const uint8 bytes[] = {
     0x55, 0x29, 0x66, 0x26, 0x6b, 0x9c, 0x73, 0x54
   };
   static size_t current_byte = 0;
   for (size_t i = 0; i < n; ++i) {
     output[i] = bytes[current_byte++];
     current_byte %= arraysize(bytes);
@@ skipping 5311 matching lines @@
   std::string expected_group_name;
   bool ssl;
 };
 
 scoped_refptr<HttpNetworkSession> SetupSessionForGroupNameTests(
     SessionDependencies* session_deps) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
-  http_server_properties->SetAlternateProtocol(
-      HostPortPair("host.with.alternate", 80), 443,
-      NPN_SPDY_21);
-
+  SetAlternateProtocol(http_server_properties,
+                       HostPortPair("host.with.alternate", 80),
+                       443,
+                       NPN_SPDY_21);
   return session;
 }
 
 int GroupNameTransactionHelper(
     const std::string& url,
     const scoped_refptr<HttpNetworkSession>& session) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(url);
   request.load_flags = 0;
@@ skipping 924 matching lines @@
   ASSERT_TRUE(http_server_properties.HasAlternateProtocol(http_host_port_pair));
   const PortAlternateProtocolPair alternate =
       http_server_properties.GetAlternateProtocol(http_host_port_pair);
   PortAlternateProtocolPair expected_alternate;
   expected_alternate.port = 443;
   expected_alternate.protocol = NPN_SPDY_21;
   EXPECT_TRUE(expected_alternate.Equals(alternate));
 
   HttpStreamFactory::set_use_alternate_protocols(false);
   HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::set_highest_supported_alternate_protocol(NPN_SPDY_21);
 }
 
 TEST_F(HttpNetworkTransactionTest, MarkBrokenAlternateProtocolAndFallback) {
   HttpStreamFactory::set_use_alternate_protocols(true);
   SessionDependencies session_deps;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
@@ skipping 11 matching lines @@
   StaticSocketDataProvider second_data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   // Port must be < 1024, or the header will be ignored (since initial port was
   // port 80 (another restricted port).
-  http_server_properties->SetAlternateProtocol(
-      HostPortPair::FromURL(request.url),
-      666 /* port is ignored by MockConnect anyway */,
-      NPN_SPDY_21);
+  SetAlternateProtocol(http_server_properties,
+                       HostPortPair::FromURL(request.url),
+                       666 /* port is ignored by MockConnect anyway */,
+                       NPN_SPDY_21);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
@@ skipping 38 matching lines @@
   };
   StaticSocketDataProvider second_data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
-  http_server_properties->SetAlternateProtocol(
-      HostPortPair::FromURL(restricted_port_request.url),
-      kUnrestrictedAlternatePort,
-      NPN_SPDY_21);
+  SetAlternateProtocol(http_server_properties,
+                       HostPortPair::FromURL(restricted_port_request.url),
+                       kUnrestrictedAlternatePort,
+                       NPN_SPDY_21);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &restricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Invalid change to unrestricted port should fail.
   EXPECT_EQ(ERR_CONNECTION_REFUSED, callback.WaitForResult());
 
@@ skipping 25 matching lines @@
   };
   StaticSocketDataProvider second_data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kRestrictedAlternatePort = 80;
-  http_server_properties->SetAlternateProtocol(
-      HostPortPair::FromURL(restricted_port_request.url),
-      kRestrictedAlternatePort,
-      NPN_SPDY_21);
+  SetAlternateProtocol(http_server_properties,
+                       HostPortPair::FromURL(restricted_port_request.url),
+                       kRestrictedAlternatePort,
+                       NPN_SPDY_21);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &restricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Valid change to restricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ skipping 25 matching lines @@
   };
   StaticSocketDataProvider second_data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kRestrictedAlternatePort = 80;
-  http_server_properties->SetAlternateProtocol(
-      HostPortPair::FromURL(unrestricted_port_request.url),
-      kRestrictedAlternatePort,
-      NPN_SPDY_21);
+  SetAlternateProtocol(http_server_properties,
+                       HostPortPair::FromURL(unrestricted_port_request.url),
+                       kRestrictedAlternatePort,
+                       NPN_SPDY_21);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &unrestricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Valid change to restricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ skipping 25 matching lines @@
   };
   StaticSocketDataProvider second_data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
-  http_server_properties->SetAlternateProtocol(
-      HostPortPair::FromURL(unrestricted_port_request.url),
-      kUnrestrictedAlternatePort,
-      NPN_SPDY_21);
+  SetAlternateProtocol(http_server_properties,
+                       HostPortPair::FromURL(unrestricted_port_request.url),
+                       kUnrestrictedAlternatePort,
+                       NPN_SPDY_21);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &unrestricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Valid change to an unrestricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ skipping 21 matching lines @@
   };
   StaticSocketDataProvider data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnsafePort = 7;
-  http_server_properties->SetAlternateProtocol(
-      HostPortPair::FromURL(request.url),
-      kUnsafePort,
-      NPN_SPDY_2);
+  SetAlternateProtocol(http_server_properties,
+                       HostPortPair::FromURL(request.url),
+                       kUnsafePort,
+                       NPN_SPDY_21);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // The HTTP request should succeed.
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Disable alternate protocol before the asserts.
@@ skipping 2486 matching lines @@
   StaticSocketDataProvider* data[] = { &data1, &data2 };
 
   SimpleGetHelperResult out = SimpleGetHelperForData(data, arraysize(data));
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
 }
 
 }  // namespace net