Fix QUIC alternate protocol behavior so that that main job does not wait

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 43 matching lines @@
 namespace test {
 
 class QuicNetworkTransactionTest : public PlatformTest {
  protected:
   QuicNetworkTransactionTest()
       : clock_(new MockClock),
         ssl_config_service_(new SSLConfigServiceDefaults),
         proxy_service_(ProxyService::CreateDirect()),
         compressor_(new QuicSpdyCompressor()),
         auth_handler_factory_(
-            HttpAuthHandlerFactory::CreateDefault(&host_resolver_)) {
+            HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
+        hanging_data_(NULL, 0, NULL, 0) {
     request_.method = "GET";
     request_.url = GURL("http://www.google.com/");
     request_.load_flags = 0;
   }
 
   virtual void SetUp() {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::MessageLoop::current()->RunUntilIdle();
   }
 
@@ skipping 129 matching lines @@
     header_.public_header.guid = random_generator_.RandUint64();
     header_.public_header.reset_flag = false;
     header_.public_header.version_flag = should_include_version;
     header_.packet_sequence_number = sequence_number;
     header_.fec_group = 0;
     header_.entropy_flag = false;
     header_.fec_flag = false;
   }
 
   void CreateSession() {
+    CreateSessionWithFactory(&socket_factory_);
+  }
+
+  void CreateSessionWithFactory(ClientSocketFactory* socket_factory) {
     params_.enable_quic = true;
     params_.quic_clock = clock_;
     params_.quic_random = &random_generator_;
-    params_.client_socket_factory = &socket_factory_;
+    params_.client_socket_factory = socket_factory;
     params_.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
     params_.host_resolver = &host_resolver_;
     params_.cert_verifier = &cert_verifier_;
     params_.transport_security_state = &transport_security_state_;
     params_.proxy_service = proxy_service_.get();
     params_.ssl_config_service = ssl_config_service_.get();
     params_.http_auth_handler_factory = auth_handler_factory_.get();
     params_.http_server_properties = &http_server_properties;
 
     session_ = new HttpNetworkSession(params_);
@@ skipping 61 matching lines @@
   void ExpectBrokenAlternateProtocolMapping() {
     ASSERT_TRUE(session_->http_server_properties()->HasAlternateProtocol(
         HostPortPair::FromURL(request_.url)));
     const PortAlternateProtocolPair alternate =
         session_->http_server_properties()->GetAlternateProtocol(
             HostPortPair::FromURL(request_.url));
     EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate.protocol);
   }
 
   void AddHangingNonAlternateProtocolSocketData() {
-    MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
-    StaticSocketDataProvider data(NULL, 0, NULL, 0);
-    data.set_connect_data(never_finishing_connect);
-    socket_factory_.AddSocketDataProvider(&data);
+    MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
+    hanging_data_.set_connect_data(hanging_connect);
+    socket_factory_.AddSocketDataProvider(&hanging_data_);
   }
 
   QuicPacketHeader header_;
   scoped_refptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockClock* clock_;  // Owned by QuicStreamFactory after CreateSession.
   MockHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
   TransportSecurityState transport_security_state_;
   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
   scoped_ptr<ProxyService> proxy_service_;
   scoped_ptr<QuicSpdyCompressor> compressor_;
   scoped_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
   MockRandom random_generator_;
   HttpServerPropertiesImpl http_server_properties;
   HttpNetworkSession::Params params_;
   HttpRequestInfo request_;
   CapturingBoundNetLog net_log_;
+  StaticSocketDataProvider hanging_data_;
 };
 
 TEST_F(QuicNetworkTransactionTest, ForceQuic) {
   params_.origin_to_force_quic_on =
       HostPortPair::FromString("www.google.com:80");
 
   QuicStreamId stream_id = 3;
   scoped_ptr<QuicEncryptedPacket> req(
       ConstructDataPacket(1, stream_id, true, true, 0,
                           GetRequestString("GET", "/")));
@@ skipping 148 matching lines @@
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
   SendRequestAndExpectQuicResponse("hello!");
 }
 
+TEST_F(QuicNetworkTransactionTest, HungAlternateProtocol) {
+  HttpStreamFactory::EnableNpnSpdy();  // 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[] = {
+    MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHttpHeader),
+    MockRead(SYNCHRONOUS, 5, "hello world"),
+    MockRead(SYNCHRONOUS, OK, 6)
+  };
+
+  DeterministicMockClientSocketFactory socket_factory;
+
+  DeterministicSocketData http_data(http_reads, arraysize(http_reads),
+                                    http_writes, arraysize(http_writes));
+  socket_factory.AddSocketDataProvider(&http_data);
+
+  // The QUIC transaction will not be allowed to complete.
+  MockWrite quic_writes[] = {
+    MockWrite(ASYNC, ERR_IO_PENDING, 0)
+  };
+  MockRead quic_reads[] = {
+    MockRead(ASYNC, ERR_IO_PENDING, 1),
+  };
+  DeterministicSocketData quic_data(quic_reads, arraysize(quic_reads),
+                                    quic_writes, arraysize(quic_writes));
+  socket_factory.AddSocketDataProvider(&quic_data);
+
+  // The HTTP transaction will complete.
+  DeterministicSocketData http_data2(http_reads, arraysize(http_reads),
+                                     http_writes, arraysize(http_writes));
+  socket_factory.AddSocketDataProvider(&http_data2);
+
+  CreateSessionWithFactory(&socket_factory);
+
+  // Run the first request.
+  http_data.StopAfter(arraysize(http_reads) + arraysize(http_writes));
+  SendRequestAndExpectHttpResponse("hello world");
+  ASSERT_TRUE(http_data.at_read_eof());
+  ASSERT_TRUE(http_data.at_write_eof());
+
+  // Now run the second request in which the QUIC socket hangs,
+  // and verify the the transaction continues over HTTP.
+  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, DontUseAlternateProtocolForQuicHttps) {
   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"),
@@ skipping 35 matching lines @@
     MockRead(ASYNC, OK),  // EOF
   };
 
   DelayedSocketData quic_data(
       1,  // wait for one write to finish before reading.
       quic_reads, arraysize(quic_reads),
       quic_writes, arraysize(quic_writes));
 
   socket_factory_.AddSocketDataProvider(&quic_data);
 
+  // TODO(rch): Ideally, we would not need this, but since we have to do a DNS
+  // lookup, it's not synchronous.  Perhaps we can configure the HostResolver
+  // to return immediately.
+  AddHangingNonAlternateProtocolSocketData();
+
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_F(QuicNetworkTransactionTest, BrokenAlternateProtocol) {
   HttpStreamFactory::EnableNpnSpdy();  // Enables QUIC too.
 
   // Alternate-protocol job
   scoped_ptr<QuicEncryptedPacket> close(ConstructConnectionClosePacket(1));
@@ skipping 48 matching lines @@
 
   CreateSession();
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
   SendRequestAndExpectHttpResponse("hello from http");
   ExpectBrokenAlternateProtocolMapping();
 }
 
 }  // namespace test
 }  // namespace net