Better match IE's proxy settings....

net/proxy/single_threaded_proxy_resolver.cc

 // 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.
 
 #include "net/proxy/single_threaded_proxy_resolver.h"
 
 #include "base/thread.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_info.h"
 
 namespace net {
 
-// Runs on the worker thread to call ProxyResolver::SetPacScriptByUrl or
-// ProxyResolver::SetPacScriptByData.
-// TODO(eroman): the lifetime of this task is ill-defined; |resolver_| must
-// be valid when the task eventually is run. Make this task cancellable.
-class SetPacScriptTask : public Task {
+// SingleThreadedProxyResolver::SetPacScriptTask ------------------------------
+
+// Runs on the worker thread to call ProxyResolver::SetPacScript.
+class SingleThreadedProxyResolver::SetPacScriptTask
+    : public base::RefCountedThreadSafe<
+        SingleThreadedProxyResolver::SetPacScriptTask> {
  public:
-  SetPacScriptTask(ProxyResolver* resolver,
+  SetPacScriptTask(SingleThreadedProxyResolver* coordinator,
                    const GURL& pac_url,
-                   const std::string& bytes)
-      : resolver_(resolver), pac_url_(pac_url), bytes_(bytes) {}
-
-  virtual void Run() {
-    if (resolver_->expects_pac_bytes())
-      resolver_->SetPacScriptByData(bytes_);
-    else
-      resolver_->SetPacScriptByUrl(pac_url_);
+                   const std::string& pac_bytes,
+                   CompletionCallback* callback)
+    : coordinator_(coordinator),
+      callback_(callback),
+      pac_bytes_(pac_bytes),
+      pac_url_(pac_url),
+      origin_loop_(MessageLoop::current()) {
+    DCHECK(callback);
   }
 
+  // Start the SetPacScript request on the worker thread.
+  void Start() {
+    // TODO(eroman): Are these manual AddRef / Release necessary?
+    AddRef();  // balanced in RequestComplete
+
+    coordinator_->thread()->message_loop()->PostTask(
+        FROM_HERE, NewRunnableMethod(this, &SetPacScriptTask::DoRequest,
+        coordinator_->resolver_.get()));
+  }
+
+  void Cancel() {
+    // Clear these to inform RequestComplete that it should not try to
+    // access them.
+    coordinator_ = NULL;
+    callback_ = NULL;
+  }
+
+  // Returns true if Cancel() has been called.
+  bool was_cancelled() const { return callback_ == NULL; }
+
  private:
-  ProxyResolver* resolver_;
+  // Runs on the worker thread.
+  void DoRequest(ProxyResolver* resolver) {
+    int rv = resolver->expects_pac_bytes() ?
+        resolver->SetPacScriptByData(pac_bytes_, NULL) :
+        resolver->SetPacScriptByUrl(pac_url_, NULL);
+
+    DCHECK_NE(rv, ERR_IO_PENDING);
+    origin_loop_->PostTask(FROM_HERE,
+        NewRunnableMethod(this, &SetPacScriptTask::RequestComplete, rv));
+  }
+
+  // Runs the completion callback on the origin thread.
+  void RequestComplete(int result_code) {
+    // The task may have been cancelled after it was started.
+    if (!was_cancelled()) {
+      CompletionCallback* callback = callback_;
+      coordinator_->RemoveOutstandingSetPacScriptTask(this);
+      callback->Run(result_code);
+    }
+
+    Release();  // Balances the AddRef in Start.
+  }
+
+  // Must only be used on the "origin" thread.
+  SingleThreadedProxyResolver* coordinator_;
+  CompletionCallback* callback_;
+  std::string pac_bytes_;
   GURL pac_url_;
-  std::string bytes_;
+
+  // Usable from within DoQuery on the worker thread.
+  MessageLoop* origin_loop_;
 };
 
 // SingleThreadedProxyResolver::Job -------------------------------------------
 
 class SingleThreadedProxyResolver::Job
     : public base::RefCountedThreadSafe<SingleThreadedProxyResolver::Job> {
  public:
   // |coordinator| -- the SingleThreadedProxyResolver that owns this job.
   // |url|         -- the URL of the query.
   // |results|     -- the structure to fill with proxy resolve results.
@@ skipping 50 matching lines @@
         results_->Use(results_buf_);
       }
       callback_->Run(result_code);
 
       // We check for cancellation once again, in case the callback deleted
       // the owning ProxyService (whose destructor will in turn cancel us).
       if (!was_cancelled())
         coordinator_->RemoveFrontOfJobsQueueAndStartNext(this);
     }
 
-    Release();  // balances the AddRef in Query.  we may get deleted after
+    Release();  // Balances the AddRef in Start. We may get deleted after
                 // we return.
   }
 
   // Must only be used on the "origin" thread.
   SingleThreadedProxyResolver* coordinator_;
   CompletionCallback* callback_;
   ProxyInfo* results_;
   GURL url_;
   bool is_started_;
 
@@ skipping 11 matching lines @@
 }
 
 SingleThreadedProxyResolver::~SingleThreadedProxyResolver() {
   // Cancel the inprogress job (if any), and free the rest.
   for (PendingJobsQueue::iterator it = pending_jobs_.begin();
        it != pending_jobs_.end();
        ++it) {
     (*it)->Cancel();
   }
 
+  if (outstanding_set_pac_script_task_)
+    outstanding_set_pac_script_task_->Cancel();
+
   // Note that |thread_| is destroyed before |resolver_|. This is important
   // since |resolver_| could be running on |thread_|.
 }
 
 int SingleThreadedProxyResolver::GetProxyForURL(const GURL& url,
                                                 ProxyInfo* results,
                                                 CompletionCallback* callback,
                                                 RequestHandle* request) {
   DCHECK(callback);
 
@@ skipping 28 matching lines @@
     return;
   }
 
   // Otherwise just delete the job from the queue.
   PendingJobsQueue::iterator it = std::find(
       pending_jobs_.begin(), pending_jobs_.end(), job);
   DCHECK(it != pending_jobs_.end());
   pending_jobs_.erase(it);
 }
 
-void SingleThreadedProxyResolver::SetPacScriptByUrlInternal(
-    const GURL& pac_url) {
-  SetPacScriptHelper(pac_url, std::string());
+void SingleThreadedProxyResolver::CancelSetPacScript() {
+  DCHECK(outstanding_set_pac_script_task_);
+  outstanding_set_pac_script_task_->Cancel();
+  outstanding_set_pac_script_task_ = NULL;
 }
 
-void SingleThreadedProxyResolver::SetPacScriptByDataInternal(
-    const std::string& bytes) {
-  SetPacScriptHelper(GURL(), bytes);
-}
+int SingleThreadedProxyResolver::SetPacScript(
+    const GURL& pac_url,
+    const std::string& pac_bytes,
+    CompletionCallback* callback) {
+  EnsureThreadStarted();
+  DCHECK(!outstanding_set_pac_script_task_);
 
-void SingleThreadedProxyResolver::SetPacScriptHelper(const GURL& pac_url,
-                                                     const std::string& bytes) {
-  EnsureThreadStarted();
-  thread()->message_loop()->PostTask(
-      FROM_HERE, new SetPacScriptTask(resolver(), pac_url, bytes));
+  SetPacScriptTask* task = new SetPacScriptTask(
+      this, pac_url, pac_bytes, callback);
+  outstanding_set_pac_script_task_ = task;
+  task->Start();
+  return ERR_IO_PENDING;
 }
 
 void SingleThreadedProxyResolver::EnsureThreadStarted() {
   if (!thread_.get()) {
     thread_.reset(new base::Thread("pac-thread"));
     thread_->Start();
   }
 }
 
 void SingleThreadedProxyResolver::ProcessPendingJobs() {
@@ skipping 11 matching lines @@
 
 void SingleThreadedProxyResolver::RemoveFrontOfJobsQueueAndStartNext(
     Job* expected_job) {
   DCHECK_EQ(expected_job, pending_jobs_.front().get());
   pending_jobs_.pop_front();
 
   // Start next work item.
   ProcessPendingJobs();
 }
 
+void SingleThreadedProxyResolver::RemoveOutstandingSetPacScriptTask(
+    SetPacScriptTask* task) {
+  DCHECK_EQ(outstanding_set_pac_script_task_.get(), task);
+  outstanding_set_pac_script_task_ = NULL;
+}
+
 }  // namespace net