Split ProxyResolver into two interfaces:...

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"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <winhttp.h>
 #endif
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
-#include "net/proxy/proxy_resolver_fixed.h"
-#include "net/proxy/proxy_resolver_null.h"
+#include "net/proxy/proxy_config_service_fixed.h"
 #if defined(OS_WIN)
 #include "net/http/http_transaction_winhttp.h"
+#include "net/proxy/proxy_config_service_win.h"
 #include "net/proxy/proxy_resolver_winhttp.h"
 #elif defined(OS_MACOSX)
 #include "net/proxy/proxy_resolver_mac.h"
 #endif
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace net {
 
+// Config getter that fails every time.
+class ProxyConfigServiceNull : public ProxyConfigService {
+ public:
+  virtual int GetProxyConfig(ProxyConfig* config) {
+    return ERR_NOT_IMPLEMENTED;
+  }
+};
+
+
 // ProxyConfig ----------------------------------------------------------------
 
 // static
 ProxyConfig::ID ProxyConfig::last_id_ = ProxyConfig::INVALID_ID;
 
 ProxyConfig::ProxyConfig()
     : auto_detect(false),
       proxy_bypass_local_names(false),
       id_(++last_id_) {
 }
@@ skipping 221 matching lines @@
   ProxyConfig::ID config_id_;
 
   // Usable from within DoQuery on the PAC thread.
   ProxyInfo results_buf_;
   GURL pac_url_;
   MessageLoop* origin_loop_;
 };
 
 // ProxyService ---------------------------------------------------------------
 
-ProxyService::ProxyService(ProxyResolver* resolver)
-    : resolver_(resolver),
+ProxyService::ProxyService(ProxyConfigService* config_service,
+                           ProxyResolver* resolver)
+    : config_service_(config_service),
+      resolver_(resolver),
       config_is_bad_(false),
       config_has_been_updated_(false) {
 }
 
 // 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).
     ProxyService* proxy_service =
-        new ProxyService(new ProxyResolverFixed(*pi));
+        new ProxyService(new ProxyConfigServiceFixed(*pi), NULL);
 
     // TODO(eroman): remove this WinHTTP hack once it is no more.
     // We keep a copy of the ProxyInfo that was used to create the
     // proxy service, so we can pass it to WinHTTP.
     proxy_service->proxy_info_.reset(new ProxyInfo(*pi));
 
     return proxy_service;
   }
 #if defined(OS_WIN)
-  return new ProxyService(new ProxyResolverWinHttp());
+  return new ProxyService(new ProxyConfigServiceWin(),
+                          new ProxyResolverWinHttp());
 #elif defined(OS_MACOSX)
-  return new ProxyService(new ProxyResolverMac());
+  return new ProxyService(new ProxyConfigServiceMac(),
+                          new ProxyResolverMac());
 #else
   // This used to be a NOTIMPLEMENTED(), but that logs as an error,
   // screwing up layout tests.
   LOG(WARNING) << "Proxies are not implemented; remove me once that's fixed.";
   // http://code.google.com/p/chromium/issues/detail?id=4523 is the bug
   // to implement this.
-  return new ProxyService(new ProxyResolverNull());
+  return CreateNull();
 #endif
 }
 
+// static
+ProxyService* ProxyService::CreateNull() {
+  // The ProxyResolver is set to NULL, since it should never be called
+  // (because the configuration will never require PAC).
+  return new ProxyService(new ProxyConfigServiceNull, NULL);
+}
+
 int ProxyService::ResolveProxy(const GURL& url, ProxyInfo* result,
                                CompletionCallback* callback,
                                PacRequest** pac_request) {
-  // The overhead of calling WinHttpGetIEProxyConfigForCurrentUser is very low.
+  // The overhead of calling ProxyConfigService::GetProxyConfig is very low.
   const TimeDelta kProxyConfigMaxAge = TimeDelta::FromSeconds(5);
 
   // Periodically check for a new config.
   if (!config_has_been_updated_ ||
       (TimeTicks::Now() - config_last_update_time_) > kProxyConfigMaxAge)
     UpdateConfig();
   result->config_id_ = config_.id();
 
   // Fallback to a "direct" (no proxy) connection if the current configuration
   // is known to be bad.
@@ skipping 152 matching lines @@
     return;
 
   // Remember that this configuration doesn't work.
   config_is_bad_ = true;
 }
 
 void ProxyService::UpdateConfig() {
   config_has_been_updated_ = true;
 
   ProxyConfig latest;
-  if (resolver_->GetProxyConfig(&latest) != OK)
+  if (config_service_->GetProxyConfig(&latest) != OK)
     return;
   config_last_update_time_ = TimeTicks::Now();
 
   if (latest.Equals(config_))
     return;
 
   config_ = latest;
   config_is_bad_ = false;
 
   // We have a new config, we should clear the list of bad proxies.
@@ skipping 41 matching lines @@
     // http://www.tcd.ie/iss/internet/osx_proxy.php for a real-world example).
     // That's kinda cool so we'll provide that for everyone.
     // TODO(avi): implement here
   }
 
   return false;
 }
 
 }  // namespace net