[SPDY] Do not advertise SPDY/2 by default

net/quic/quic_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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "net/base/capturing_net_log.h"
 #include "net/base/net_log_unittest.h"
@@ skipping 438 matching lines @@
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_F(QuicNetworkTransactionTest, UseAlternateProtocolForQuic) {
-  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
+  HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kQuicAlternateProtocolHttpHeader),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
@@ skipping 32 matching lines @@
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_F(QuicNetworkTransactionTest, UseAlternateProtocolForQuicForHttps) {
   params_.origin_to_force_quic_on =
       HostPortPair::FromString("www.google.com:443");
   params_.enable_quic_https = true;
-  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
+  HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kQuicAlternateProtocolHttpsHeader),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
@@ skipping 29 matching lines @@
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
 
   // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo().
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_F(QuicNetworkTransactionTest, HungAlternateProtocol) {
-  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
+  HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
   crypto_client_stream_factory_.set_handshake_mode(
       MockCryptoClientStream::COLD_START);
 
   MockWrite http_writes[] = {
     MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
     MockWrite(SYNCHRONOUS, 1, "Host: www.google.com\r\n"),
     MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")
   };
 
   MockRead http_reads[] = {
@@ skipping 38 matching lines @@
   http_data2.StopAfter(arraysize(http_reads) + arraysize(http_writes));
   SendRequestAndExpectHttpResponse("hello world");
 
   ASSERT_TRUE(http_data2.at_read_eof());
   ASSERT_TRUE(http_data2.at_write_eof());
   ASSERT_TRUE(!quic_data.at_read_eof());
   ASSERT_TRUE(!quic_data.at_write_eof());
 }
 
 TEST_F(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) {
-  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
+  HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   scoped_ptr<QuicEncryptedPacket> req(
       ConstructDataPacket(1, 3, true, true, 0,
                           GetRequestString("GET", "http", "/")));
   scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0));
 
   MockWrite quic_writes[] = {
     MockWrite(SYNCHRONOUS, req->data(), req->length()),
     MockWrite(SYNCHRONOUS, ack->data(), ack->length()),
   };
@@ skipping 16 matching lines @@
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_F(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) {
-  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
+  HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   scoped_ptr<QuicEncryptedPacket> req(
       ConstructDataPacket(1, 3, true, true, 0,
                           GetRequestString("GET", "http", "/")));
   scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0));
 
   MockWrite quic_writes[] = {
     MockWrite(SYNCHRONOUS, req->data(), req->length()),
     MockWrite(SYNCHRONOUS, ack->data(), ack->length()),
   };
@@ skipping 26 matching lines @@
                          CompletionCallback(),
                          NULL,
                          net_log_.bound());
 
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_F(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) {
-  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
+  HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   scoped_ptr<QuicEncryptedPacket> req(
       ConstructDataPacket(1, 3, true, true, 0,
                           GetRequestString("GET", "http", "/")));
   scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0));
 
   MockWrite quic_writes[] = {
     MockWrite(SYNCHRONOUS, req->data(), req->length()),
     MockWrite(SYNCHRONOUS, ack->data(), ack->length()),
   };
@@ skipping 38 matching lines @@
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
       QuicSession::HANDSHAKE_CONFIRMED);
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 TEST_F(QuicNetworkTransactionTest, BrokenAlternateProtocol) {
-  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
+  HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   // Alternate-protocol job
   scoped_ptr<QuicEncryptedPacket> close(ConstructConnectionClosePacket(1));
   MockRead quic_reads[] = {
     MockRead(ASYNC, close->data(), close->length()),
     MockRead(ASYNC, OK),  // EOF
   };
   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
                                      NULL, 0);
   socket_factory_.AddSocketDataProvider(&quic_data);
@@ skipping 10 matching lines @@
                                      NULL, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
   SendRequestAndExpectHttpResponse("hello from http");
   ExpectBrokenAlternateProtocolMapping();
 }
 
 TEST_F(QuicNetworkTransactionTest, BrokenAlternateProtocolReadError) {
-  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
+  HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   // Alternate-protocol job
   MockRead quic_reads[] = {
     MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
   };
   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
                                      NULL, 0);
   socket_factory_.AddSocketDataProvider(&quic_data);
 
   // Main job which will succeed even though the alternate job fails.
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello from http"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      NULL, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   CreateSession();
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
   SendRequestAndExpectHttpResponse("hello from http");
   ExpectBrokenAlternateProtocolMapping();
 }
 
 TEST_F(QuicNetworkTransactionTest, FailedZeroRttBrokenAlternateProtocol) {
-  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
+  HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   // Alternate-protocol job
   MockRead quic_reads[] = {
     MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
   };
   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
                                      NULL, 0);
   socket_factory_.AddSocketDataProvider(&quic_data);
 
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   scoped_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
 
   ExpectBrokenAlternateProtocolMapping();
 }
 
 }  // namespace test
 }  // namespace net