Making command-line specified proxy settings more flexible - allowing for set...

net/proxy/proxy_service.cc

 // Copyright (c) 2006-2008 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 53 matching lines @@
  private:
   ProxyResolver* resolver_;
   std::string bytes_;
 };
 
 // ProxyService::PacRequest ---------------------------------------------------
 
 // We rely on the fact that the origin thread (and its message loop) will not
 // be destroyed until after the PAC thread is destroyed.
 
-class ProxyService::PacRequest :
-    public base::RefCountedThreadSafe<ProxyService::PacRequest> {
+class ProxyService::PacRequest
+    : public base::RefCountedThreadSafe<ProxyService::PacRequest> {
  public:
   // |service| -- the ProxyService that owns this request.
   // |url|     -- the url of the query.
   // |results| -- the structure to fill with proxy resolve results.
   PacRequest(ProxyService* service,
              const GURL& url,
              ProxyInfo* results,
              CompletionCallback* callback)
       : service_(service),
         callback_(callback),
@@ skipping 100 matching lines @@
       next_config_id_(1),
       config_is_bad_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(proxy_script_fetcher_callback_(
           this, &ProxyService::OnScriptFetchCompletion)),
       fetched_pac_config_id_(ProxyConfig::INVALID_ID),
       fetched_pac_error_(OK),
       in_progress_fetch_config_id_(ProxyConfig::INVALID_ID) {
 }
 
 // static
-ProxyService* ProxyService::Create(const ProxyInfo* pi) {
-  if (pi) {
-    // The ProxyResolver is set to NULL, since it should never be called
-    // (because the configuration will never require PAC).
-    return new ProxyService(new ProxyConfigServiceFixed(*pi), NULL);
+ProxyService* ProxyService::Create(const ProxyConfig* pc) {
+  scoped_ptr<ProxyConfigService> proxy_config_service;
+  scoped_ptr<ProxyResolver> proxy_resolver;
+  if (pc) {
+    proxy_config_service.reset(new ProxyConfigServiceFixed(*pc));
   }
+
 #if defined(OS_WIN)
-  return new ProxyService(new ProxyConfigServiceWin(),
-                          new ProxyResolverWinHttp());
+  if (proxy_config_service == NULL)
+    proxy_config_service.reset(new ProxyConfigServiceWin());
+  proxy_resolver.reset(new ProxyResolverWinHttp());
 #elif defined(OS_MACOSX)
-  return new ProxyService(new ProxyConfigServiceMac(),
-                          new ProxyResolverMac());
+  if (proxy_config_service == NULL)
+    proxy_config_service.reset(new ProxyConfigServiceMac());
+  proxy_resolver.reset(new ProxyResolverMac());
 #elif defined(OS_LINUX)
   // On Linux we use the V8Resolver, no fallback implementation.
-  return CreateNull();
+  // This means that if we got called with a ProxyConfig that could require a
+  // resolver, or if the caller is trying to create a regular ProxyService via
+  // this method instead of CreateUsingV8Resolver() we have to return a
+  // nulled-out ProxyService.
+  if (!pc || pc->MayRequirePACResolver()) {
+    LOG(WARNING) << "Attempting to create a ProxyService with a non-v8 "
+                 << "resolver using an invalid ProxyConfig.";
+    return CreateNull();
+  }
 #else
   return CreateNull();
 #endif
+
+  return new ProxyService(proxy_config_service.release(),
+                          proxy_resolver.release());
 }
 
 // static
 ProxyService* ProxyService::CreateUsingV8Resolver(
-    const ProxyInfo* pi, URLRequestContext* url_request_context) {
-  if (pi) {
-    // The ProxyResolver is set to NULL, since it should never be called
-    // (because the configuration will never require PAC).
-    return new ProxyService(new ProxyConfigServiceFixed(*pi), NULL);
+    const ProxyConfig* pc, URLRequestContext* url_request_context) {
+  // Choose the system configuration service appropriate for each platform.
+  ProxyConfigService* config_service = NULL;
+  if (pc) {
+    config_service = new ProxyConfigServiceFixed(*pc);
+  } else {
+#if defined(OS_WIN)
+    config_service = new ProxyConfigServiceWin();
+#elif defined(OS_MACOSX)
+    config_service = new ProxyConfigServiceMac();
+#elif defined(OS_LINUX)
+    config_service = new ProxyConfigServiceLinux();
+#else
+    return CreateNull();
+#endif
   }
 
-  // Choose the system configuration service appropriate for each platform.
-  ProxyConfigService* config_service;
-#if defined(OS_WIN)
-  config_service = new ProxyConfigServiceWin();
-#elif defined(OS_MACOSX)
-  config_service = new ProxyConfigServiceMac();
-#elif defined(OS_LINUX)
-  config_service = new ProxyConfigServiceLinux();
-#else
-  return CreateNull();
-#endif
-
   // Create a ProxyService that uses V8 to evaluate PAC scripts.
   ProxyService* proxy_service = new ProxyService(
       config_service, new ProxyResolverV8());
 
   // Configure PAC script downloads to be issued using |url_request_context|.
   proxy_service->SetProxyScriptFetcher(
       ProxyScriptFetcher::Create(url_request_context));
 
   return proxy_service;
 }
@@ skipping 461 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net