Add support to ProxyService for downloading a PAC script on behalf of the Pro...

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 <deque>
 #include <map>
 #include <string>
 #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 "base/waitable_event.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/completion_callback.h"
+#include "net/proxy/proxy_script_fetcher.h"
 #include "net/proxy/proxy_server.h"
 
 class GURL;
 
 namespace net {
 
 class ProxyConfigService;
 class ProxyInfo;
 class ProxyResolver;
 
@@ skipping 65 matching lines @@
 
 // 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 |config_service| and |resolver|.
   ProxyService(ProxyConfigService* config_service,
                ProxyResolver* resolver);
 
+  ~ProxyService();
+
   // Used internally to handle PAC queries.
   class PacRequest;
 
   // Returns ERR_IO_PENDING if the proxy information could not be provided
   // synchronously, 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|
   // remain valid until the callback is run or until |pac_request| is cancelled
@@ skipping 34 matching lines @@
 
   // 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();
 
+  // Set the ProxyScriptFetcher dependency. This is needed if the ProxyResolver
+  // is of type ProxyResolverWithoutFetch. ProxyService takes ownership of
+  // |proxy_script_fetcher|.
+  void SetProxyScriptFetcher(ProxyScriptFetcher* proxy_script_fetcher) {
+    proxy_script_fetcher_.reset(proxy_script_fetcher);
+  }
+
  private:
   friend class PacRequest;
 
   ProxyResolver* resolver() { return resolver_.get(); }
   base::Thread* pac_thread() { return pac_thread_.get(); }
 
   // Identifies the proxy configuration.
   ProxyConfig::ID config_id() const { return config_.id(); }
 
   // Checks to see if the proxy configuration changed, and then updates config_
   // to reference the new configuration.
   void UpdateConfig();
 
+  // Tries to update the configuration if it hasn't been checked in a while.
+  void UpdateConfigIfOld();
+
+  // Returns true if this ProxyService is downloading a PAC script on behalf
+  // of ProxyResolverWithoutFetch. Resolve requests will be frozen until
+  // the fetch has completed.
+  bool IsFetchingPacScript() const {
+    return in_progress_fetch_config_id_ != ProxyConfig::INVALID_ID;
+  }
+
+  // Callback for when the PAC script has finished downloading.
+  void OnScriptFetchCompletion(int result);
+  
+  // Returns ERR_IO_PENDING if the request cannot be completed synchronously.
+  // Otherwise it fills |result| with the proxy information for |url|.
+  // Completing synchronously means we don't need to query ProxyResolver.
+  // (ProxyResolver runs on PAC thread.)
+  int TryToCompleteSynchronously(const GURL& url, ProxyInfo* result);
+
+  // Starts the PAC thread if it isn't already running.
+  void InitPacThread();
+
+  // Starts the next request from |pending_requests_| is possible.
+  // |recent_req| is the request that just got added, or NULL.
+  void ProcessPendingRequests(PacRequest* recent_req);
+
+  // Removes the front entry of the requests queue. |expected_req| is our
+  // expectation of what the front of the request queue is; it is only used by
+  // DCHECK for verification purposes.
+  void RemoveFrontOfRequestQueue(PacRequest* expected_req);
+
   // Called to indicate that a PacRequest completed.  The |config_id| parameter
   // indicates the proxy configuration that was queried.  |result_code| is OK
   // 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.
@@ skipping 12 matching lines @@
 
   // false if the ProxyService has not been initialized yet.
   bool config_has_been_updated_;
 
   // The time when the proxy configuration was last read from the system.
   base::TimeTicks config_last_update_time_;
 
   // Map of the known bad proxies and the information about the retry time.
   ProxyRetryInfoMap proxy_retry_info_;
 
+  // FIFO queue of pending/inprogress requests.
+  typedef std::deque<scoped_refptr<PacRequest> > PendingRequestsQueue;
+  PendingRequestsQueue pending_requests_;
+
+  // The fetcher to use when downloading PAC scripts for the ProxyResolver.
+  // This dependency can be NULL if our ProxyResolver has no need for
+  // external PAC script fetching.
+  scoped_ptr<ProxyScriptFetcher> proxy_script_fetcher_;
+
+  // Callback for when |proxy_script_fetcher_| is done.
+  CompletionCallbackImpl<ProxyService> proxy_script_fetcher_callback_;
+
+  // The ID of the configuration for which we last downloaded a PAC script.
+  // If no PAC script has been fetched yet, will be ProxyConfig::INVALID_ID.
+  ProxyConfig::ID fetched_pac_config_id_;
+
+  // The error corresponding with |fetched_pac_config_id_|, or OK.
+  int fetched_pac_error_;
+
+  // The ID of the configuration for which we are currently downloading the
+  // PAC script. If no fetch is in progress, will be ProxyConfig::INVALID_ID.
+  ProxyConfig::ID in_progress_fetch_config_id_;
+
+  // The results of the current in progress fetch, or empty string.
+  std::string in_progress_fetch_bytes_;
+
   DISALLOW_COPY_AND_ASSIGN(ProxyService);
 };
 
 // This class is used to hold a list of proxies returned by GetProxyForUrl or
 // manually configured. It handles proxy fallback if multiple servers are
 // specified.
 class ProxyList {
  public:
   // Initializes the proxy list to a string containing one or more proxy servers
   // delimited by a semicolon.
@@ skipping 103 matching lines @@
   // 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:
+
+  // 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) {}
+
   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;
+
+  // 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|.
+    NOTREACHED();
+  }
+
+  bool does_fetch() const { return does_fetch_; }
+
+ protected:
+  bool does_fetch_;
 };
 
 // Wrapper for invoking methods on a ProxyService synchronously.
 class SyncProxyServiceHelper
     : public base::RefCountedThreadSafe<SyncProxyServiceHelper> {
  public:
   SyncProxyServiceHelper(MessageLoop* io_message_loop,
                          ProxyService* proxy_service);
 
   int ResolveProxy(const GURL& url, ProxyInfo* proxy_info);
@@ skipping 11 matching lines @@
   base::WaitableEvent event_;
   CompletionCallbackImpl<SyncProxyServiceHelper> callback_;
   ProxyInfo proxy_info_;
   int result_;
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_PROXY_SERVICE_H_