Split ProxyResolver into two interfaces:...

net/proxy/proxy_service.h

 // 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.
 
 #ifndef NET_PROXY_PROXY_SERVICE_H_
 #define NET_PROXY_PROXY_SERVICE_H_
 
 #include <map>
 #include <vector>
 
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/completion_callback.h"
 
 #if defined(OS_WIN)
 typedef LPVOID HINTERNET;  // From winhttp.h
 #endif
 
 class GURL;
 
 namespace net {
 
+class ProxyConfigService;
 class ProxyInfo;
 class ProxyResolver;
 
 // Proxy configuration used to by the ProxyService.
 class ProxyConfig {
  public:
   typedef int ID;
 
   // Indicates an invalid proxy config.
   enum { INVALID_ID = 0 };
@@ skipping 41 matching lines @@
 };
 
 // Map of proxy servers with the associated RetryInfo structures.
 typedef std::map<std::string, ProxyRetryInfo> ProxyRetryInfoMap;
 
 // This class can be used to resolve the proxy server to use when loading a
 // HTTP(S) URL.  It uses the given ProxyResolver to handle the actual proxy
 // resolution.  See ProxyResolverWinHttp for example.
 class ProxyService {
  public:
-  // The instance takes ownership of |resolver|.
-  explicit ProxyService(ProxyResolver* resolver);
+  // The instance takes ownership of |config_service| and |resolver|.
+  ProxyService(ProxyConfigService* config_service,
+               ProxyResolver* resolver);
 
   // Used internally to handle PAC queries.
   class PacRequest;
 
   // Returns OK if proxy information could be provided synchronously.  Else,
   // ERR_IO_PENDING is returned to indicate that the result will be available
   // when the callback is run.  The callback is run on the thread that calls
   // ResolveProxy.
   //
   // The caller is responsible for ensuring that |results| and |callback|
@@ skipping 31 matching lines @@
                                 PacRequest** pac_request);
 
   // Call this method with a non-null |pac_request| to cancel the PAC request.
   void CancelPacRequest(PacRequest* pac_request);
 
   // Create a proxy service using the specified settings. If |pi| is NULL then
   // the system's default proxy settings will be used (on Windows this will
   // use IE's settings).
   static ProxyService* Create(const ProxyInfo* pi);
 
+  // Create a proxy service that always fails to fetch the proxy configuration,
+  // so it falls back to direct connect.
+  static ProxyService* CreateNull();
+
   // TODO(eroman): remove once WinHTTP is gone.
   // Get the ProxyInfo used to create this proxy service (only used by WinHTTP).
   const ProxyInfo* proxy_info() const {
     return proxy_info_.get();
   }
 
  private:
   friend class PacRequest;
 
   ProxyResolver* resolver() { return resolver_.get(); }
@@ skipping 11 matching lines @@
   // if the PAC file could be downloaded and executed.  Otherwise, it is an
   // error code, indicating a bad proxy configuration.
   void DidCompletePacRequest(int config_id, int result_code);
 
   // Returns true if the URL passed in should not go through the proxy server.
   // 1. If the bypass proxy list contains the string <local> and the URL
   //    passed in is a local URL, i.e. a URL without a DOT (.)
   // 2. The URL matches one of the entities in the proxy bypass list.
   bool ShouldBypassProxyForURL(const GURL& url);
 
+  scoped_ptr<ProxyConfigService> config_service_;
   scoped_ptr<ProxyResolver> resolver_;
   scoped_ptr<base::Thread> pac_thread_;
 
   // We store the proxy config and a counter that is incremented each time
   // the config changes.
   ProxyConfig config_;
 
   // TODO(eroman): remove this once WinHTTP stack is gone.
   scoped_ptr<ProxyInfo> proxy_info_;
 
@@ skipping 99 matching lines @@
   // This value identifies the proxy config used to initialize this object.
   ProxyConfig::ID config_id_;
 
   // This flag is false when the proxy configuration was known to be bad when
   // this proxy info was initialized.  In such cases, we know that if this
   // proxy info does not yield a connection that we might want to reconsider
   // the proxy config given by config_id_.
   bool config_was_tried_;
 };
 
-// This interface provides the low-level functions to access the proxy
-// configuration and resolve proxies for given URLs synchronously.
-class ProxyResolver {
+// Synchronously fetch the system's proxy configuration settings. Called on
+// the IO Thread.
+class ProxyConfigService {
  public:
-  virtual ~ProxyResolver() {}
+  virtual ~ProxyConfigService() {}
 
   // Get the proxy configuration.  Returns OK if successful or an error code if
   // otherwise.  |config| should be in its initial state when this method is
   // called.
   virtual int GetProxyConfig(ProxyConfig* config) = 0;
+};
+
+// Synchronously resolve the proxy for a URL, using a PAC script. Called on the
+// PAC Thread.
+class ProxyResolver {
+ public:
+  virtual ~ProxyResolver() {}
 
   // Query the proxy auto-config file (specified by |pac_url|) for the proxy to
   // use to load the given |query_url|.  Returns OK if successful or an error
-  // code if otherwise.
+  // code otherwise.
   virtual int GetProxyForURL(const GURL& query_url,
                              const GURL& pac_url,
                              ProxyInfo* results) = 0;
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_PROXY_SERVICE_H_