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