Cleanup the preconnect to proxy code and Job controller 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 <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "net/base/port_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_proxy_delegate.h"
 #include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/bidirectional_stream_impl.h"
@@ skipping 1183 matching lines @@
     HttpRequestInfo request;
     request.method = "GET";
     request.url = url;
     request.load_flags = 0;
 
     session->http_stream_factory()->PreconnectStreams(num_streams, request);
     EXPECT_EQ(-1, transport_conn_pool->last_num_streams());
   }
 }
 
-// Verify that the proxy delegate can disable preconnect jobs to only the proxy
-// servers that support request priorities.
-TEST_F(HttpStreamFactoryTest, ProxyDelegateDisablesPreconnect) {
-  base::FieldTrialList field_trial_list(nullptr);
-  base::FieldTrialList::CreateFieldTrial(
-      "NetAllowOnlyOnePreconnectToProxyServers", "Enabled");
-
+// Verify that only one preconnect job succeeds to a proxy server that supports
+// request priorities.
+TEST_F(HttpStreamFactoryTest, OnlyOnePreconnectToProxyServer) {
   for (bool set_http_server_properties : {false, true}) {
     for (int num_streams = 1; num_streams < 3; ++num_streams) {
       base::HistogramTester histogram_tester;
       GURL url = GURL("http://www.google.com");
       std::unique_ptr<ProxyService> proxy_service =
           ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443");
 
       // Set up the proxy server as a server that supports request priorities.
       HttpServerPropertiesImpl http_server_properties;
       if (set_http_server_properties) {
         url::SchemeHostPort spdy_server("https", "myproxy.org", 443);
         http_server_properties.SetSupportsSpdy(spdy_server, true);
       }
 
       SpdySessionDependencies session_deps;
       HttpNetworkSession::Params params =
           SpdySessionDependencies::CreateSessionParams(&session_deps);
       params.enable_quic = true;
       params.proxy_service = proxy_service.get();
       params.http_server_properties = &http_server_properties;
+      ASSERT_TRUE(params.restrict_to_one_preconnect_for_proxies);
 
       std::unique_ptr<HttpNetworkSession> session(
           new HttpNetworkSession(params));
 
       HttpNetworkSessionPeer peer(session.get());
       HostPortPair proxy_host("myproxy.org", 443);
 
       for (int preconnect_request = 0; preconnect_request < 2;
            ++preconnect_request) {
         CapturePreconnectsHttpProxySocketPool* http_proxy_pool =
@@ skipping 345 matching lines @@
       HostPortPair("myproxy", 8888))));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
       HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
       HostPortPair("myproxy", 8888))));
   EXPECT_FALSE(waiter.used_proxy_info().is_direct());
 }
 
 // Verifies that once a stream has been created to a proxy server (that supports
 // request priorities) the next preconnect job can again open new sockets.
 TEST_F(HttpStreamFactoryTest, RequestHttpStreamOverProxyWithPreconnects) {
-  base::FieldTrialList field_trial_list(nullptr);
-  base::FieldTrialList::CreateFieldTrial(
-      "NetAllowOnlyOnePreconnectToProxyServers", "Enabled");
-
   SpdySessionDependencies session_deps(
       ProxyService::CreateFixed("https://myproxy.org:443"));
 
   // Set up the proxy server as a server that supports request priorities.
   std::unique_ptr<HttpServerPropertiesImpl> http_server_properties(
       new HttpServerPropertiesImpl());
   url::SchemeHostPort spdy_server("https", "myproxy.org", 443);
   http_server_properties->SetSupportsSpdy(spdy_server, true);
   session_deps.http_server_properties = std::move(http_server_properties);
 
@@ skipping 885 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