Revert of Remove obsolete QUIC disabling code.

net/http/http_stream_factory_impl_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_stream_factory_impl.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 1073 matching lines @@
       // not used for subsequent requests.
       EXPECT_FALSE(test_proxy_delegate.alternative_proxy_server().is_quic());
 
       // GetAlternativeProxy should be called only once per request.
       EXPECT_EQ(static_cast<int>(i + 1),
                 test_proxy_delegate.get_alternative_proxy_invocations());
     }
   }
 }
 
+TEST_F(HttpStreamFactoryTest, QuicLossyProxyMarkedAsBad) {
+  // Checks if a
+  std::unique_ptr<ProxyService> proxy_service;
+  proxy_service = ProxyService::CreateFixedFromPacResult("QUIC bad:99; DIRECT");
+
+  HttpNetworkSession::Params params;
+  params.enable_quic = true;
+  params.quic_disable_preconnect_if_0rtt = false;
+  scoped_refptr<SSLConfigServiceDefaults> ssl_config_service(
+      new SSLConfigServiceDefaults);
+  HttpServerPropertiesImpl http_server_properties;
+  MockClientSocketFactory socket_factory;
+  params.client_socket_factory = &socket_factory;
+  MockHostResolver host_resolver;
+  params.host_resolver = &host_resolver;
+  MockCertVerifier cert_verifier;
+  params.cert_verifier = &cert_verifier;
+  TransportSecurityState transport_security_state;
+  params.transport_security_state = &transport_security_state;
+  MultiLogCTVerifier ct_verifier;
+  params.cert_transparency_verifier = &ct_verifier;
+  CTPolicyEnforcer ct_policy_enforcer;
+  params.ct_policy_enforcer = &ct_policy_enforcer;
+  params.proxy_service = proxy_service.get();
+  params.ssl_config_service = ssl_config_service.get();
+  params.http_server_properties = &http_server_properties;
+  params.quic_max_number_of_lossy_connections = 2;
+
+  std::unique_ptr<HttpNetworkSession> session(new HttpNetworkSession(params));
+  session->quic_stream_factory()->set_require_confirmation(false);
+
+  session->quic_stream_factory()->number_of_lossy_connections_[99] =
+      params.quic_max_number_of_lossy_connections;
+  session->quic_stream_factory()->MaybeDisableQuic(99);
+  ASSERT_TRUE(session->quic_stream_factory()->IsQuicDisabled(99));
+
+  StaticSocketDataProvider socket_data2;
+  socket_data2.set_connect_data(MockConnect(ASYNC, OK));
+  socket_factory.AddSocketDataProvider(&socket_data2);
+
+  // Now request a stream. It should succeed using the second proxy in the
+  // list.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("http://www.google.com");
+
+  SSLConfig ssl_config;
+  StreamRequestWaiter waiter;
+  std::unique_ptr<HttpStreamRequest> request(
+      session->http_stream_factory()->RequestStream(
+          request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
+          BoundNetLog()));
+  waiter.WaitForStream();
+
+  // The proxy that failed should now be known to the proxy_service as bad.
+  const ProxyRetryInfoMap& retry_info =
+      session->proxy_service()->proxy_retry_info();
+  EXPECT_EQ(1u, retry_info.size());
+  EXPECT_TRUE(waiter.used_proxy_info().is_direct());
+
+  ProxyRetryInfoMap::const_iterator iter = retry_info.find("quic://bad:99");
+  EXPECT_TRUE(iter != retry_info.end());
+}
+
 TEST_F(HttpStreamFactoryTest, UsePreConnectIfNoZeroRTT) {
   for (int num_streams = 1; num_streams < 3; ++num_streams) {
     GURL url = GURL("https://www.google.com");
 
     // Set up QUIC as alternative_service.
     HttpServerPropertiesImpl http_server_properties;
     const AlternativeService alternative_service(QUIC, url.host().c_str(),
                                                  url.IntPort());
     AlternativeServiceInfoVector alternative_service_info_vector;
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
@@ skipping 1147 matching lines @@
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 }
 
 }  // namespace
 
 }  // namespace net