Remove the concept of threading from ProxyService, and move it into the Proxy...

net/proxy/proxy_resolver.h

Index: net/proxy/proxy_resolver.h
===================================================================
--- net/proxy/proxy_resolver.h	(revision 21630)
+++ net/proxy/proxy_resolver.h	(working copy)
@@ -8,6 +8,7 @@
 #include <string>
 
 #include "base/logging.h"
+#include "net/base/completion_callback.h"
 
 class GURL;
 
@@ -15,37 +16,69 @@
 
 class ProxyInfo;
 
-// Synchronously resolve the proxy for a URL, using a PAC script. Called on the
-// PAC Thread.
+// Interface for "proxy resolvers". A ProxyResolver fills in a list of proxies
+// to use for a particular URL. Generally the backend for a ProxyResolver is
+// a PAC script, but it doesn't need to be. ProxyResolver can service multiple
+// requests at a time.
 class ProxyResolver {
  public:
+  // Opaque pointer type, to return a handle to cancel outstanding requests.
+  typedef void* RequestHandle;
 
-  // If a subclass sets |does_fetch| to false, then the owning ProxyResolver
-  // will download PAC scripts on our behalf, and notify changes with
-  // SetPacScript(). Otherwise the subclass is expected to fetch the
-  // PAC script internally, and SetPacScript() will go unused.
-  ProxyResolver(bool does_fetch) : does_fetch_(does_fetch) {}
+  // See |expects_pac_bytes()| for the meaning of |expects_pac_bytes|.
+  explicit ProxyResolver(bool expects_pac_bytes)
+      : expects_pac_bytes_(expects_pac_bytes) {}
 
   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 otherwise.
-  virtual int GetProxyForURL(const GURL& query_url,
-                             const GURL& pac_url,
-                             ProxyInfo* results) = 0;
+  // Gets a list of proxy servers to use for |url|. If the request will
+  // complete asynchronously returns ERR_IO_PENDING and notifies the result
+  // by running |callback|.  If the result code is OK then
+  // the request was successful and |results| contains the proxy
+  // resolution information.  In the case of asynchronous completion
+  // |*request| is written to, and can be passed to CancelRequest().
+  virtual int GetProxyForURL(const GURL& url,
+                             ProxyInfo* results,
+                             CompletionCallback* callback,
+                             RequestHandle* request) = 0;
 
-  // Called whenever the PAC script has changed, with the contents of the
-  // PAC script. |bytes| may be empty string if there was a fetch error.
-  virtual void SetPacScript(const std::string& bytes) {
-    // Must override SetPacScript() if |does_fetch_ = true|.
+  // Cancels |request|.
+  virtual void CancelRequest(RequestHandle request) = 0;
+
+  // The PAC script backend can be specified to the ProxyResolver either via
+  // URL, or via the javascript text itself.  If |expects_pac_bytes| is true,
+  // then PAC scripts should be specified using SetPacScriptByData(). Otherwise
+  // they should be specified using SetPacScriptByUrl().
+  bool expects_pac_bytes() const { return expects_pac_bytes_; }
+
+  // Sets the PAC script backend to use for this proxy resolver (by URL).
+  void SetPacScriptByUrl(const GURL& pac_url) {
+    DCHECK(!expects_pac_bytes());
+    SetPacScriptByUrlInternal(pac_url);
+  }
+
+  // Sets the PAC script backend to use for this proxy resolver (by contents).
+  void SetPacScriptByData(const std::string& bytes) {
+    DCHECK(expects_pac_bytes());
+    SetPacScriptByDataInternal(bytes);
+  }
+
+ private:
+  // Called to set the PAC script backend to use. If |pac_url| is invalid,
+  // this is a request to use WPAD (auto detect).
+  virtual void SetPacScriptByUrlInternal(const GURL& pac_url) {
     NOTREACHED();
   }
 
-  bool does_fetch() const { return does_fetch_; }
+  // Called to set the PAC script backend to use. |bytes| may be empty if the
+  // fetch failed, or if the fetch returned no content.
+  virtual void SetPacScriptByDataInternal(const std::string& bytes) {
+    NOTREACHED();
+  }
 
- protected:
-  bool does_fetch_;
+  const bool expects_pac_bytes_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProxyResolver);
 };
 
 }  // namespace net