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 6476 matching lines @@
       AuthCredentials(kFirst, kBar), callback4.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback4.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 }
 
 TEST_F(HttpNetworkTransactionTest, HonorAlternateProtocolHeader) {
-  HttpStreamFactory::set_next_protos(MakeNextProtos("foo", "bar", NULL));
+  HttpStreamFactory::SetNextProtos(MakeNextProtos(
+      "foo", "bar", "http/1.1", "spdy/2", "spdy/2.1", NULL));

[Ryan Hamilton, 2012/03/02 16:46:53]

I'm not sure that I understand the significance of the values here.  Do we need
foo and bar?  If yes, do we need the others?

[ramant (doing other things), 2012/03/02 18:40:41]

We definitely need spdy/2 and/or spdy/2.1 (I am not sure about "foo" and "bar").
Removed "foo" and "bar".

   HttpStreamFactory::set_use_alternate_protocols(true);
 
   SessionDependencies session_deps;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
@@ skipping 36 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::SetNextProtos(std::vector<std::string>());
 }
 
 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 293 matching lines @@
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 }
 
 TEST_F(HttpNetworkTransactionTest, UseAlternateProtocolForNpnSpdy) {
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::set_next_protos(SpdyNextProtos());
+  HttpStreamFactory::SetNextProtos(SpdyNextProtos());
   SessionDependencies session_deps;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
@@ skipping 62 matching lines @@
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
 
-  HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, AlternateProtocolWithSpdyLateBinding) {
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::set_next_protos(SpdyNextProtos());
+  HttpStreamFactory::SetNextProtos(SpdyNextProtos());
   SessionDependencies session_deps;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
@@ skipping 89 matching lines @@
 
   response = trans3.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans3, &response_data));
   EXPECT_EQ("hello!", response_data);
 
-  HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, StallAlternateProtocolForNpnSpdy) {
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::set_next_protos(SpdyNextProtos());
+  HttpStreamFactory::SetNextProtos(SpdyNextProtos());
   SessionDependencies session_deps;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
@@ skipping 47 matching lines @@
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
 
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
-  HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 class CapturingProxyResolver : public ProxyResolver {
  public:
   CapturingProxyResolver() : ProxyResolver(false /* expects_pac_bytes */) {}
   virtual ~CapturingProxyResolver() {}
 
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
@@ skipping 34 matching lines @@
   const std::vector<GURL>& resolved() const { return resolved_; }
 
  private:
   std::vector<GURL> resolved_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingProxyResolver);
 };
 
 TEST_F(HttpNetworkTransactionTest, UseAlternateProtocolForTunneledNpnSpdy) {
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::set_next_protos(SpdyNextProtos());
+  HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   ProxyConfig proxy_config;
   proxy_config.set_auto_detect(true);
   proxy_config.set_pac_url(GURL("http://fooproxyurl"));
 
   CapturingProxyResolver* capturing_proxy_resolver =
       new CapturingProxyResolver();
   SessionDependencies session_deps(new ProxyService(
       new ProxyConfigServiceFixed(proxy_config), capturing_proxy_resolver,
       NULL));
@@ skipping 85 matching lines @@
   EXPECT_TRUE(response->was_npn_negotiated);
 
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
   ASSERT_EQ(3u, capturing_proxy_resolver->resolved().size());
   EXPECT_EQ("http://www.google.com/",
             capturing_proxy_resolver->resolved()[0].spec());
   EXPECT_EQ("https://www.google.com/",
             capturing_proxy_resolver->resolved()[1].spec());
 
-  HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest,
        UseAlternateProtocolForNpnSpdyWithExistingSpdySession) {
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::set_next_protos(SpdyNextProtos());
+  HttpStreamFactory::SetNextProtos(SpdyNextProtos());
   SessionDependencies session_deps;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
@@ skipping 90 matching lines @@
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
 
-  HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 // GenerateAuthToken is a mighty big test.
 // It tests all permutation of GenerateAuthToken behavior:
 //   - Synchronous and Asynchronous completion.
 //   - OK or error on completion.
 //   - Direct connection, non-authenticating proxy, and authenticating proxy.
 //   - HTTP or HTTPS backend (to include proxy tunneling).
 //   - Non-authenticating and authenticating backend.
@@ skipping 700 matching lines @@
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("ok.", response_data);
 }
 
 // This tests the case that a request is issued via http instead of spdy after
 // npn is negotiated.
 TEST_F(HttpNetworkTransactionTest, NpnWithHttpOverSSL) {
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::set_next_protos(
+  HttpStreamFactory::SetNextProtos(
       MakeNextProtos("http/1.1", "http1.1", NULL));
   SessionDependencies session_deps;
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
@@ skipping 33 matching lines @@
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
-  HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, SpdyPostNPNServerHangup) {
   // Simulate the SSL handshake completing with an NPN negotiation
   // followed by an immediate server closing of the socket.
   // Fix crash:  http://crbug.com/46369
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::set_next_protos(SpdyNextProtos());
+  HttpStreamFactory::SetNextProtos(SpdyNextProtos());
   SessionDependencies session_deps;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
@@ skipping 14 matching lines @@
 
   TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
 
-  HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, SpdyAlternateProtocolThroughProxy) {
   // This test ensures that the URL passed into the proxy is upgraded
   // to https when doing an Alternate Protocol upgrade.
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::set_next_protos(
+  HttpStreamFactory::SetNextProtos(
       MakeNextProtos(
           "http/1.1", "http1.1", "spdy/2.1", "spdy/2", "spdy", NULL));
 
   SessionDependencies session_deps(ProxyService::CreateFixed("myproxy:70"));
   HttpAuthHandlerMock::Factory* auth_factory =
       new HttpAuthHandlerMock::Factory();
   HttpAuthHandlerMock* auth_handler = new HttpAuthHandlerMock();
   auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_PROXY);
   auth_factory->set_do_init_from_challenge(true);
   session_deps.http_auth_handler_factory.reset(auth_factory);
@@ skipping 124 matching lines @@
       AuthCredentials(kFoo, kBar), callback_3.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback_3.WaitForResult());
 
   // After all that work, these two lines (or actually, just the scheme) are
   // what this test is all about. Make sure it happens correctly.
   const GURL& request_url = auth_handler->request_url();
   EXPECT_EQ("https", request_url.scheme());
   EXPECT_EQ("www.google.com", request_url.host());
 
-  HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 // Test that if we cancel the transaction as the connection is completing, that
 // everything tears down correctly.
 TEST_F(HttpNetworkTransactionTest, SimpleCancel) {
   // Setup everything about the connection to complete synchronously, so that
   // after calling HttpNetworkTransaction::Start, the only thing we're waiting
   // for is the callback from the HttpStreamRequest.
   // Then cancel the transaction.
@@ skipping 625 matching lines @@
   // MockClientSocket::GetPeerAddress but that returns 192.0.2.33 whereas
   // MockHostResolver returns 127.0.0.1 (MockHostResolverBase::Reset). So we use
   // the first address (127.0.0.1) returned by MockHostResolver as an alias for
   // the |pair|.
   const addrinfo* address = addresses.head();
   pool_peer->AddAlias(address, pair);
 }
 
 TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) {
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::set_next_protos(SpdyNextProtos());
+  HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   // Set up a special HttpNetworkSession with a MockCachingHostResolver.
   SessionDependencies session_deps;
   MockCachingHostResolver host_resolver;
   net::HttpNetworkSession::Params params;
   params.client_socket_factory = &session_deps.socket_factory;
   params.host_resolver = &host_resolver;
   params.cert_verifier = session_deps.cert_verifier.get();
   params.proxy_service = session_deps.proxy_service.get();
   params.ssl_config_service = session_deps.ssl_config_service;
@@ skipping 86 matching lines @@
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans2, &response_data));
   EXPECT_EQ("hello!", response_data);
 
-  HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 class OneTimeCachingHostResolver : public net::HostResolver {
  public:
   explicit OneTimeCachingHostResolver(const HostPortPair& host_port)
       : host_port_(host_port) {}
   virtual ~OneTimeCachingHostResolver() {}
 
   RuleBasedHostResolverProc* rules() { return host_resolver_.rules(); }
@@ skipping 26 matching lines @@
   }
 
  private:
   MockCachingHostResolver host_resolver_;
   const HostPortPair host_port_;
 };
 
 TEST_F(HttpNetworkTransactionTest,
        UseIPConnectionPoolingWithHostCacheExpiration) {
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::set_next_protos(SpdyNextProtos());
+  HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   // Set up a special HttpNetworkSession with a OneTimeCachingHostResolver.
   SessionDependencies session_deps;
   OneTimeCachingHostResolver host_resolver(HostPortPair("www.gmail.com", 443));
   net::HttpNetworkSession::Params params;
   params.client_socket_factory = &session_deps.socket_factory;
   params.host_resolver = &host_resolver;
   params.cert_verifier = session_deps.cert_verifier.get();
   params.proxy_service = session_deps.proxy_service.get();
   params.ssl_config_service = session_deps.ssl_config_service;
@@ skipping 85 matching lines @@
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans2, &response_data));
   EXPECT_EQ("hello!", response_data);
 
-  HttpStreamFactory::set_next_protos(std::vector<std::string>());
+  HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, ReadPipelineEvictionFallback) {
   MockRead data_reads1[] = {
     MockRead(SYNCHRONOUS, ERR_PIPELINE_EVICTION),
   };
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
@@ skipping 31 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