Change the default number of proxy resolver threads used for evaluating PAC s...

net/proxy/proxy_service.cc

 // Copyright (c) 2010 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/proxy/proxy_service.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 21 matching lines @@
 #include "net/proxy/proxy_resolver_v8.h"
 #include "net/proxy/sync_host_resolver_bridge.h"
 #include "net/url_request/url_request_context.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace net {
 
 static const size_t kMaxNumNetLogEntries = 100;
+static const size_t kDefaultNumPacThreads = 4;
 
 // Config getter that fails every time.
 class ProxyConfigServiceNull : public ProxyConfigService {
  public:
   // ProxyConfigService implementation:
   virtual int GetProxyConfig(ProxyConfig* config) {
     return ERR_NOT_IMPLEMENTED;
   }
 };
 
@@ skipping 205 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(init_proxy_resolver_callback_(
           this, &ProxyService::OnInitProxyResolverComplete)),
       net_log_(net_log) {
   NetworkChangeNotifier::AddObserver(this);
 }
 
 // static
 ProxyService* ProxyService::Create(
     ProxyConfigService* proxy_config_service,
     bool use_v8_resolver,
+    size_t num_pac_threads,
     URLRequestContext* url_request_context,
     NetLog* net_log,
     MessageLoop* io_loop) {
+  if (num_pac_threads == 0)
+    num_pac_threads = kDefaultNumPacThreads;
 
   ProxyResolverFactory* sync_resolver_factory;
   if (use_v8_resolver) {
     sync_resolver_factory =
         new ProxyResolverFactoryForV8(
             url_request_context->host_resolver(),
             io_loop);
   } else {
     sync_resolver_factory = new ProxyResolverFactoryForNonV8();
   }
 
-  const size_t kMaxNumResolverThreads = 1u;
   ProxyResolver* proxy_resolver =
-      new MultiThreadedProxyResolver(sync_resolver_factory,
-                                     kMaxNumResolverThreads);
+      new MultiThreadedProxyResolver(sync_resolver_factory, num_pac_threads);
 
   ProxyService* proxy_service =
       new ProxyService(proxy_config_service, proxy_resolver, net_log);
 
   if (proxy_resolver->expects_pac_bytes()) {
     // Configure PAC script downloads to be issued using |url_request_context|.
     DCHECK(url_request_context);
     proxy_service->SetProxyScriptFetcher(
         ProxyScriptFetcher::Create(url_request_context));
   }
 
   return proxy_service;
 }
 
 // static
 ProxyService* ProxyService::CreateFixed(const ProxyConfig& pc) {
-  return Create(new ProxyConfigServiceFixed(pc), false, NULL, NULL, NULL);
+  // TODO(eroman): This isn't quite right, won't work if |pc| specifies
+  //               a PAC script.
+  return Create(new ProxyConfigServiceFixed(pc), false, 0, NULL, NULL, NULL);
 }
 
 // static
 ProxyService* ProxyService::CreateNull() {
   // Use a configuration fetcher and proxy resolver which always fail.
   return new ProxyService(new ProxyConfigServiceNull, new ProxyResolverNull,
                           NULL);
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
@@ skipping 444 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net