Race preconnects to HTTP2 proxies that support alternate proxies

net/quic/chromium/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 <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 682 matching lines @@
     EXPECT_TRUE(session_->proxy_service()->proxy_retry_info().empty());
 
     // The alternative proxy server should no longer be in use.
     EXPECT_FALSE(test_proxy_delegate.alternative_proxy_server().is_valid());
 
     // Verify that the second request completes successfully, and the
     // alternative proxy server job is not started.
     SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443);
   }
 
+  // Preconnects to a HTTPS proxy with a QUIC alternative proxy. Verifies that
+  // if the alternative proxy job returns |error_code|, the preconnection still
+  // succeeds.
+  void TestAlternativeProxyPreconnect(int error_code) {
+    base::HistogramTester histogram_tester;
+    // Data for the alternative proxy server job.
+    MockWrite quic_writes[] = {MockWrite(SYNCHRONOUS, error_code, 1)};
+    MockRead quic_reads[] = {
+        MockRead(SYNCHRONOUS, error_code, 0),
+    };
+
+    SequencedSocketData quic_data(quic_reads, arraysize(quic_reads),
+                                  quic_writes, arraysize(quic_writes));
+    socket_factory_.AddSocketDataProvider(&quic_data);
+
+    // Main job succeeds and the alternative job fails.
+    // Add data for two requests that will be read by the main job.
+    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_1(http_reads, arraysize(http_reads),
+                                         nullptr, 0);
+    socket_factory_.AddSocketDataProvider(&http_data_1);
+    socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
+
+    TestProxyDelegate test_proxy_delegate;
+    // Proxy URL is different from the request URL.
+    test_proxy_delegate.set_alternative_proxy_server(
+        ProxyServer::FromPacString("QUIC myproxy.org:443"));
+
+    params_.proxy_delegate = &test_proxy_delegate;
+    params_.race_preconnects_to_http2_proxies = true;
+    proxy_service_ =
+        ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443");
+
+    CreateSession();
+    EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_valid());
+
+    HttpRequestInfo request_info;
+    request_info.method = "GET";
+    // Use a non-cryptographic scheme for the preconnect URL since this will be
+    // fetched via proxy with QUIC as the alternative service.
+    request_info.url = GURL("http://www.google.com");
+
+    session_->http_stream_factory()->PreconnectStreams(1 /*num_streams*/,
+                                                       request_info);
+    base::RunLoop().RunUntilIdle();
+
+    // Even through the alternative proxy server job failed, the proxy should
+    // not be marked as bad since the main job succeeded.
+    EXPECT_TRUE(session_->proxy_service()->proxy_retry_info().empty());
+
+    // The alternative proxy server should no longer be in use.
+    EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_valid());
+
+    histogram_tester.ExpectTotalCount(
+        "Net.QuicAlternativeProxy.PreconnectRace.FirstJobFinished", 1);
+  }
+
   const QuicVersion version_;
   QuicFlagSaver flags_;  // Save/restore all QUIC flag values.
   MockClock* clock_;  // Owned by QuicStreamFactory after CreateSession.
   QuicTestPacketMaker client_maker_;
   QuicTestPacketMaker server_maker_;
   std::unique_ptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   ProofVerifyDetailsChromium verify_details_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockHostResolver host_resolver_;
@@ skipping 1133 matching lines @@
   EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic());
 
   // Verify that the proxy server is not marked as broken.
   EXPECT_TRUE(session_->proxy_service()->proxy_retry_info().empty());
 
   histogram_tester.ExpectUniqueSample("Net.QuicAlternativeProxy.Usage",
                                       1 /* ALTERNATIVE_PROXY_USAGE_WON_RACE */,
                                       1);
 }
 
+// Tests that the connection to an HTTPS proxy is raced with an available
+// alternative proxy server.
+TEST_P(QuicNetworkTransactionTest, QuicProxyWithRacingForPreconnect) {
+  base::HistogramTester histogram_tester;
+  proxy_service_ =
+      ProxyService::CreateFixedFromPacResult("HTTPS mail.example.org:443");
+
+  MockQuicData mock_quic_data;
+  QuicStreamOffset header_stream_offset = 0;
+  mock_quic_data.AddWrite(ConstructSettingsPacket(
+      1, SETTINGS_MAX_HEADER_LIST_SIZE, kDefaultMaxUncompressedHeaderSize,
+      &header_stream_offset));
+  mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
+      2, kClientDataStreamId1, true, true,
+      GetRequestHeaders("GET", "http", "/"), &header_stream_offset));
+  mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
+      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
+                                                   false, true, 0, "hello!"));
+  mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1));
+  mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
+  mock_quic_data.AddRead(ASYNC, 0);               // EOF
+
+  mock_quic_data.AddSocketDataToFactory(&socket_factory_);
+
+  // There is no need to set up main job, because no attempt will be made to
+  // speak to the proxy over TCP.
+  params_.enable_quic_alternative_service_with_different_host = false;
+  TestProxyDelegate test_proxy_delegate;
+  const HostPortPair host_port_pair("mail.example.org", 443);
+
+  test_proxy_delegate.set_alternative_proxy_server(
+      ProxyServer::FromPacString("QUIC mail.example.org:443"));
+  params_.proxy_delegate = &test_proxy_delegate;
+  params_.race_preconnects_to_http2_proxies = true;
+  CreateSession();
+  EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic());
+
+  // The main job needs to hang in order to guarantee that the alternative
+  // proxy server job will "win".
+  AddHangingNonAlternateProtocolSocketData();
+
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("http://www.google.com");
+
+  session_->http_stream_factory()->PreconnectStreams(1 /* num_streams */,
+                                                     request_info);
+  base::RunLoop().RunUntilIdle();
+  histogram_tester.ExpectTotalCount(
+      "Net.QuicAlternativeProxy.PreconnectRace.FirstJobFinished", 1);
+
+  // Verify that the alternative proxy server is not marked as broken.
+  EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic());
+
+  // Verify that the proxy server is not marked as broken.
+  EXPECT_TRUE(session_->proxy_service()->proxy_retry_info().empty());
+}
+
 TEST_P(QuicNetworkTransactionTest, HungAlternativeService) {
   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: mail.example.org\r\n"),
       MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")};
 
   MockRead http_reads[] = {
@@ skipping 642 matching lines @@
 TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyQuicProtocolError) {
   TestAlternativeProxy(ERR_QUIC_PROTOCOL_ERROR);
 }
 TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyIOPending) {
   TestAlternativeProxy(ERR_IO_PENDING);
 }
 TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyAddressUnreachable) {
   TestAlternativeProxy(ERR_ADDRESS_UNREACHABLE);
 }
 
+TEST_P(QuicNetworkTransactionTest,
+       BrokenAlternativeProxySocketNotConnectedPreconnect) {
+  TestAlternativeProxyPreconnect(ERR_SOCKET_NOT_CONNECTED);
+}
+TEST_P(QuicNetworkTransactionTest,
+       BrokenAlternativeProxyConnectionFailedPreconnect) {
+  TestAlternativeProxyPreconnect(ERR_CONNECTION_FAILED);
+}
+TEST_P(QuicNetworkTransactionTest,
+       BrokenAlternativeProxyConnectionTimedOutPreconnect) {
+  TestAlternativeProxyPreconnect(ERR_CONNECTION_TIMED_OUT);
+}
+TEST_P(QuicNetworkTransactionTest,
+       BrokenAlternativeProxyConnectionRefusedPreconnect) {
+  TestAlternativeProxyPreconnect(ERR_CONNECTION_REFUSED);
+}
+TEST_P(QuicNetworkTransactionTest,
+       BrokenAlternativeProxyQuicHandshakeFailedPreconnect) {
+  TestAlternativeProxyPreconnect(ERR_QUIC_HANDSHAKE_FAILED);
+}
+TEST_P(QuicNetworkTransactionTest,
+       BrokenAlternativeProxyQuicProtocolErrorPreconnect) {
+  TestAlternativeProxyPreconnect(ERR_QUIC_PROTOCOL_ERROR);
+}
+TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyIOPendingPreconnect) {
+  TestAlternativeProxyPreconnect(ERR_IO_PENDING);
+}
+TEST_P(QuicNetworkTransactionTest,
+       BrokenAlternativeProxyAddressUnreachablePreconnect) {
+  TestAlternativeProxyPreconnect(ERR_ADDRESS_UNREACHABLE);
+}
+
 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnectProxy) {
   MockQuicData mock_quic_data;
   mock_quic_data.AddSynchronousRead(ConstructServerConnectionClosePacket(1));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       1, kClientDataStreamId1, true, true,
       GetRequestHeaders("GET", "https", "/")));
   mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // When the QUIC connection fails, we will try the request again over HTTP.
@@ skipping 908 matching lines @@
   AddHangingSocketData();
 
   SendRequestAndExpectQuicResponse(origin1_);
   SendRequestAndExpectQuicResponse(origin2_);
 
   EXPECT_TRUE(AllDataConsumed());
 }
 
 }  // namespace test
 }  // namespace net