Cleanup the preconnect to proxy code and Job controller code

net/http/http_stream_factory_impl.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 <string>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
-#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/http/http_stream_factory_impl_job_controller.h"
 #include "net/http/http_stream_factory_impl_request.h"
 #include "net/http/transport_security_state.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 60 matching lines @@
       GURL origin_url,
       const ProxyServer& alternative_proxy_server,
       NetLog* net_log) override {
     return new HttpStreamFactoryImpl::Job(
         delegate, job_type, session, request_info, priority, server_ssl_config,
         proxy_ssl_config, destination, origin_url, AlternativeService(),
         alternative_proxy_server, net_log);
   }
 };
 
-// Returns true if only one preconnect to proxy servers is allowed via field
-// trial.
-bool AllowOnlyOnePreconnectToProxyServers() {
-  return base::StartsWith(base::FieldTrialList::FindFullName(
-                              "NetAllowOnlyOnePreconnectToProxyServers"),
-                          "Enabled", base::CompareCase::INSENSITIVE_ASCII);
-}
-
 }  // anonymous namespace
 
 HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session,
                                              bool for_websockets)
     : session_(session),
       job_factory_(new DefaultJobFactory()),
-      for_websockets_(for_websockets),
-      allow_only_one_preconnect_to_proxy_servers_(
-          AllowOnlyOnePreconnectToProxyServers()) {}
+      for_websockets_(for_websockets) {}
 
 HttpStreamFactoryImpl::~HttpStreamFactoryImpl() {
   DCHECK(request_map_.empty());
   DCHECK(spdy_session_request_map_.empty());
 }
 
 HttpStreamRequest* HttpStreamFactoryImpl::RequestStream(
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
@@ skipping 135 matching lines @@
   NOTREACHED();
 }
 
 bool HttpStreamFactoryImpl::OnInitConnection(const JobController& controller,
                                              const ProxyInfo& proxy_info) {
   if (!controller.is_preconnect()) {
     // Connection initialization can be skipped only for the preconnect jobs.
     return false;
   }
 
-  if (!allow_only_one_preconnect_to_proxy_servers_ ||
+  if (!session_->params().restrict_to_one_preconnect_for_proxies ||
       !ProxyServerSupportsPriorities(proxy_info)) {
     return false;
   }
 
   if (base::ContainsKey(preconnecting_proxy_servers_,
                         proxy_info.proxy_server())) {
     UMA_HISTOGRAM_EXACT_LINEAR("Net.PreconnectSkippedToProxyServers", 1, 2);
     // Skip preconnect to the proxy server since we are already preconnecting
     // (probably via some other job).
     return true;
@@ skipping 32 matching lines @@
   DCHECK(!host_port_pair.IsEmpty());
 
   url::SchemeHostPort scheme_host_port("https", host_port_pair.host(),
                                        host_port_pair.port());
 
   return session_->http_server_properties()->SupportsRequestPriority(
       scheme_host_port);
 }
 
 }  // namespace net