Better match IE's proxy settings....

net/proxy/single_threaded_proxy_resolver.h

 // Copyright (c) 2009 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_SINGLE_THREADED_PROXY_RESOLVER_H_
 #define NET_PROXY_SINGLE_THREADED_PROXY_RESOLVER_H_
 
 #include <deque>
 #include <string>
 
@@ skipping 19 matching lines @@
   explicit SingleThreadedProxyResolver(ProxyResolver* resolver);
 
   virtual ~SingleThreadedProxyResolver();
 
   // ProxyResolver implementation:
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
                              CompletionCallback* callback,
                              RequestHandle* request);
   virtual void CancelRequest(RequestHandle request);
+  virtual void CancelSetPacScript();
 
  protected:
   // The wrapped (synchronous) ProxyResolver.
   ProxyResolver* resolver() { return resolver_.get(); }
 
  private:
   // Refcounted helper class that bridges between origin thread and worker
   // thread.
   class Job;
   friend class Job;
+  class SetPacScriptTask;
+  friend class SetPacScriptTask;
   // FIFO queue that contains the in-progress job, and any pending jobs.
   typedef std::deque<scoped_refptr<Job> > PendingJobsQueue;
 
   base::Thread* thread() { return thread_.get(); }
 
   // ProxyResolver implementation:
-  virtual void SetPacScriptByUrlInternal(const GURL& pac_url);
-  virtual void SetPacScriptByDataInternal(const std::string& bytes);
-
-  // Helper for shared code between SetPacScriptByUrlInternal() and
-  // SetPacScriptByDataInternal() -- the unused parameter is set to empty.
-  void SetPacScriptHelper(const GURL& pac_url, const std::string& bytes);
+  virtual int SetPacScript(const GURL& pac_url,
+                           const std::string& pac_bytes,
+                           CompletionCallback* callback);
 
   // Starts the worker thread if it isn't already running.
   void EnsureThreadStarted();
 
   // Starts the next job from |pending_jobs_| if possible.
   void ProcessPendingJobs();
 
   // Removes the front entry of the jobs queue. |expected_job| is our
   // expectation of what the front of the job queue is; it is only used by
   // DCHECK for verification purposes.
   void RemoveFrontOfJobsQueueAndStartNext(Job* expected_job);
 
+  // Clears |outstanding_set_pac_script_task_|.
+  // Called when |task| has just finished.
+  void RemoveOutstandingSetPacScriptTask(SetPacScriptTask* task);
+
   // The synchronous resolver implementation.
   scoped_ptr<ProxyResolver> resolver_;
 
   // The thread where |resolver_| is run on.
   // Note that declaration ordering is important here. |thread_| needs to be
   // destroyed *before* |resolver_|, in case |resolver_| is currently
   // executing on |thread_|.
   scoped_ptr<base::Thread> thread_;
 
   PendingJobsQueue pending_jobs_;
+  scoped_refptr<SetPacScriptTask> outstanding_set_pac_script_task_;
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_SINGLE_THREADED_PROXY_RESOLVER_H_