Add an option ProxyService::Create() to disable use of proxy auto-config....

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 175 matching lines @@
 
  private:
   HostResolver* const async_host_resolver_;
   MessageLoop* io_loop_;
 
   // Thread-safe wrapper around a non-threadsafe NetLog implementation. This
   // enables the proxy resolver to emit log messages from the PAC thread.
   scoped_ptr<ForwardingNetLog> forwarding_net_log_;
 };
 
-// Creates ProxyResolvers using a non-V8 implementation.
-class ProxyResolverFactoryForNonV8 : public ProxyResolverFactory {
+// Creates ProxyResolvers using a platform-specific implementation.
+class ProxyResolverFactoryForSystem : public ProxyResolverFactory {
  public:
-  ProxyResolverFactoryForNonV8()
+  ProxyResolverFactoryForSystem()
       : ProxyResolverFactory(false /*expects_pac_bytes*/) {}
 
   virtual ProxyResolver* CreateProxyResolver() {
+    DCHECK(IsSupported());
 #if defined(OS_WIN)
     return new ProxyResolverWinHttp();
 #elif defined(OS_MACOSX)
     return new ProxyResolverMac();
 #else
-    LOG(WARNING) << "PAC support disabled because there is no fallback "
-                    "non-V8 implementation";
-    return new ProxyResolverNull();
+    NOTREACHED();
+    return NULL;
+#endif
+  }
+
+  static bool IsSupported() {
+#if defined(OS_WIN) || defined(OS_MACOSX)
+    return true;
+#else
+    return false;
 #endif
   }
 };
 
 // NetLog parameter to describe a proxy configuration change.
 class ProxyConfigChangedNetLogParam : public NetLog::EventParameters {
  public:
   ProxyConfigChangedNetLogParam(const ProxyConfig& old_config,
                                 const ProxyConfig& new_config)
       : old_config_(old_config),
@@ skipping 153 matching lines @@
       current_state_(STATE_NONE) ,
       net_log_(net_log),
       stall_proxy_auto_config_delay_(
           base::TimeDelta::FromMilliseconds(
               kNumMillisToStallAfterNetworkChanges)) {
   NetworkChangeNotifier::AddObserver(this);
   ResetConfigService(config_service);
 }
 
 // static
-ProxyService* ProxyService::Create(
+ProxyService* ProxyService::CreateUsingV8ProxyResolver(
     ProxyConfigService* proxy_config_service,
-    bool use_v8_resolver,
     size_t num_pac_threads,
     URLRequestContext* url_request_context,
     NetLog* net_log,
     MessageLoop* io_loop) {
+  DCHECK(proxy_config_service);
+  DCHECK(url_request_context);
+  DCHECK(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,
-            net_log);
-  } else {
-    sync_resolver_factory = new ProxyResolverFactoryForNonV8();
-  }
+  ProxyResolverFactory* sync_resolver_factory =
+      new ProxyResolverFactoryForV8(
+          url_request_context->host_resolver(),
+          io_loop,
+          net_log);
 
   ProxyResolver* proxy_resolver =
       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));
+  // Configure PAC script downloads to be issued using |url_request_context|.
+  proxy_service->SetProxyScriptFetcher(
+      ProxyScriptFetcher::Create(url_request_context));
+
+  return proxy_service;
+}
+
+// static
+ProxyService* ProxyService::CreateUsingSystemProxyResolver(
+    ProxyConfigService* proxy_config_service,
+    size_t num_pac_threads,
+    NetLog* net_log) {
+  DCHECK(proxy_config_service);
+
+  if (!ProxyResolverFactoryForSystem::IsSupported()) {
+    LOG(WARNING) << "PAC support disabled because there is no "
+                    "system implementation";
+    return CreateWithoutProxyResolver(proxy_config_service, net_log);
   }
 
-  return proxy_service;
+  if (num_pac_threads == 0)
+    num_pac_threads = kDefaultNumPacThreads;
+
+  ProxyResolver* proxy_resolver = new MultiThreadedProxyResolver(
+      new ProxyResolverFactoryForSystem(), num_pac_threads);
+
+  return new ProxyService(proxy_config_service, proxy_resolver, net_log);
+}
+
+// static
+ProxyService* ProxyService::CreateWithoutProxyResolver(
+    ProxyConfigService* proxy_config_service,
+    NetLog* net_log) {
+  return new ProxyService(proxy_config_service,
+                          new ProxyResolverNull(),
+                          net_log);
 }
 
 // static
 ProxyService* ProxyService::CreateFixed(const ProxyConfig& pc) {
   // 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);
+  return CreateUsingSystemProxyResolver(new ProxyConfigServiceFixed(pc),
+                                        0, NULL);
 }
 
 // static
 ProxyService* ProxyService::CreateDirect() {
   // Use direct connections.
   return new ProxyService(new ProxyConfigServiceDirect, new ProxyResolverNull,
                           NULL);
 }
 
 // static
@@ skipping 460 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net