Actually enable Alternate-Protocol support for QUIC.

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 28 matching lines @@
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 // This is the expected return from a current server advertising QUIC.
 static const char kQuicAlternateProtocolHttpHeader[] =
-    "Alternate-Protocol: 443:quic\r\n\r\n";
-
-// Returns a vector of NPN protocol strings for negotiating QUIC.
-std::vector<std::string> QuicNextProtos() {
-  std::vector<std::string> protos;
-  protos.push_back("http/1.1");
-  protos.push_back("quic");
-  return protos;
-}
+    "Alternate-Protocol: 80:quic\r\n\r\n";
 
 }  // namespace
 
 namespace net {
 namespace test {
 
 class QuicNetworkTransactionTest : public PlatformTest {
  protected:
   QuicNetworkTransactionTest()
       : clock_(new MockClock),
@@ skipping 372 matching lines @@
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_F(QuicNetworkTransactionTest, UseAlternateProtocolForQuic) {
-  HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::SetNextProtos(QuicNextProtos());
+  HttpStreamFactory::EnableNpnSpdy();  // 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 28 matching lines @@
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_F(QuicNetworkTransactionTest, DontUseAlternateProtocolForQuicHttps) {
-  HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::SetNextProtos(QuicNextProtos());
+  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
 
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-length: 11\r\n"),
     MockRead(kQuicAlternateProtocolHttpHeader),
     MockRead("hello world"),
 
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-length: 6\r\n"),
     MockRead(kQuicAlternateProtocolHttpHeader),
     MockRead("hello!"),
   };
 
   StaticSocketDataProvider data(http_reads, arraysize(http_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
   request_.url = GURL("https://www.google.com/");
 
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
   SendRequestAndExpectHttpResponse("hello!");
 }
 
 TEST_F(QuicNetworkTransactionTest, ZeroRTT) {
-  HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::SetNextProtos(QuicNextProtos());
+  HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
 
   scoped_ptr<QuicEncryptedPacket> req(
       ConstructDataPacket(1, 3, true, true, 0, GetRequestString("GET", "/")));
   scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0));
 
   MockWrite quic_writes[] = {
     MockWrite(SYNCHRONOUS, req->data(), req->length()),
     MockWrite(SYNCHRONOUS, ack->data(), ack->length()),
   };
 
@@ skipping 11 matching lines @@
       quic_writes, arraysize(quic_writes));
 
   socket_factory_.AddSocketDataProvider(&quic_data);
 
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_F(QuicNetworkTransactionTest, BrokenAlternateProtocol) {
-  HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::SetNextProtos(QuicNextProtos());
+  HttpStreamFactory::EnableNpnSpdy();  // 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::set_use_alternate_protocols(true);
-  HttpStreamFactory::SetNextProtos(QuicNextProtos());
+  HttpStreamFactory::EnableNpnSpdy();  // 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.
@@ skipping 10 matching lines @@
 
   CreateSession();
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
   SendRequestAndExpectHttpResponse("hello from http");
   ExpectBrokenAlternateProtocolMapping();
 }
 
 }  // namespace test
 }  // namespace net