Add the capability to run multiple proxy PAC scripts in parallel.

Refactors SingleThreadedProxyResolver into MultiThreadedProxyResolver.

New threads are created lazily on demand, up to a fixed maximum.

Note that this CL does NOT change the policy in Chrome -- it will continue to use a single thread for proxy resolving, but using the new code to do so.

BUG=11079
Review URL: http://codereview.chromium.org/2822043

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@51924 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 144 insertions, 0 deletions

diff --git a/net/proxy/multi_threaded_proxy_resolver.h b/net/proxy/multi_threaded_proxy_resolver.h
new file mode 100644
index 0000000..c192251
--- /dev/null
+++ b/net/proxy/multi_threaded_proxy_resolver.h
@@ -0,0 +1,144 @@
+// 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_MULTI_THREADED_PROXY_RESOLVER_H_
+#define NET_PROXY_MULTI_THREADED_PROXY_RESOLVER_H_
+
+#include <deque>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/non_thread_safe.h"
+#include "base/ref_counted.h"
+#include "base/scoped_ptr.h"
+#include "net/proxy/proxy_resolver.h"
+
+namespace base {
+class Thread;
+}  // namespace base
+
+namespace net {
+
+// ProxyResolverFactory is an interface for creating ProxyResolver instances.
+class ProxyResolverFactory {
+ public:
+  explicit ProxyResolverFactory(bool resolvers_expect_pac_bytes)
+      : resolvers_expect_pac_bytes_(resolvers_expect_pac_bytes) {}
+
+  virtual ~ProxyResolverFactory() {}
+
+  // Creates a new ProxyResolver. The caller is responsible for freeing this
+  // object.
+  virtual ProxyResolver* CreateProxyResolver() = 0;
+
+  bool resolvers_expect_pac_bytes() const {
+    return resolvers_expect_pac_bytes_;
+  }
+
+ private:
+  bool resolvers_expect_pac_bytes_;
+  DISALLOW_COPY_AND_ASSIGN(ProxyResolverFactory);
+};
+
+// MultiThreadedProxyResolver is a ProxyResolver implementation that runs
+// synchronous ProxyResolver implementations on worker threads.
+//
+// Threads are created lazily on demand, up to a maximum total. The advantage
+// of having a pool of threads, is faster performance. In particular, being
+// able to keep servicing PAC requests even if one blocks its execution.
+//
+// During initialization (SetPacScript), a single thread is spun up to test
+// the script. If this succeeds, we cache the input script, and will re-use
+// this to lazily provision any new threads as needed.
+//
+// For each new thread that we spawn, a corresponding new ProxyResolver is
+// created using ProxyResolverFactory.
+//
+// Because we are creating multiple ProxyResolver instances, this means we
+// are duplicating script contexts for what is ordinarily seen as being a
+// single script. This can affect compatibility on some classes of PAC
+// script:
+//
+// (a) Scripts whose initialization has external dependencies on network or
+//     time may end up successfully initializing on some threads, but not
+//     others. So depending on what thread services the request, the result
+//     may jump between several possibilities.
+//
+// (b) Scripts whose FindProxyForURL() depends on side-effects may now
+//     work differently. For example, a PAC script which was incrementing
+//     a global counter and using that to make a decision. In the
+//     multi-threaded model, each thread may have a different value for this
+//     counter, so it won't globally be seen as monotonically increasing!
+class MultiThreadedProxyResolver : public ProxyResolver, public NonThreadSafe {
+ public:
+  // Creates an asynchronous ProxyResolver that runs requests on up to
+  // |max_num_threads|.
+  //
+  // For each thread that is created, an accompanying synchronous ProxyResolver
+  // will be provisioned using |resolver_factory|. All methods on these
+  // ProxyResolvers will be called on the one thread, with the exception of
+  // ProxyResolver::Shutdown() which will be called from the origin thread
+  // prior to destruction.
+  //
+  // The constructor takes ownership of |resolver_factory|.
+  MultiThreadedProxyResolver(ProxyResolverFactory* resolver_factory,
+                             size_t max_num_threads);
+
+  virtual ~MultiThreadedProxyResolver();
+
+  // ProxyResolver implementation:
+  virtual int GetProxyForURL(const GURL& url,
+                             ProxyInfo* results,
+                             CompletionCallback* callback,
+                             RequestHandle* request,
+                             const BoundNetLog& net_log);
+  virtual void CancelRequest(RequestHandle request);
+  virtual void CancelSetPacScript();
+  virtual void PurgeMemory();
+
+ private:
+  class Executor;
+  class Job;
+  class SetPacScriptJob;
+  class GetProxyForURLJob;
+  // FIFO queue of pending jobs waiting to be started.
+  // TODO(eroman): Make this priority queue.
+  typedef std::deque<scoped_refptr<Job> > PendingJobsQueue;
+  typedef std::vector<scoped_refptr<Executor> > ExecutorList;
+
+  // ProxyResolver implementation:
+  virtual int SetPacScript(const GURL& pac_url,
+                           const string16& pac_script,
+                           CompletionCallback* callback);
+
+  // Asserts that there are no outstanding user-initiated jobs on any of the
+  // worker threads.
+  void CheckNoOutstandingUserRequests() const;
+
+  // Stops and deletes all of the worker threads.
+  void ReleaseAllExecutors();
+
+  // Returns an idle worker thread which is ready to receive GetProxyForURL()
+  // requests. If all threads are occupied, returns NULL.
+  Executor* FindIdleExecutor();
+
+  // Creates a new worker thread, and appends it to |executors_|.
+  Executor* AddNewExecutor();
+
+  // Starts the next job from |pending_jobs_| if possible.
+  void OnExecutorReady(Executor* executor);
+
+  const scoped_ptr<ProxyResolverFactory> resolver_factory_;
+  const size_t max_num_threads_;
+  PendingJobsQueue pending_jobs_;
+  ExecutorList executors_;
+  bool was_set_pac_script_called_;
+  GURL current_pac_url_;
+  string16 current_pac_script_;
+};
+
+}  // namespace net
+
+#endif  // NET_PROXY_MULTI_THREADED_PROXY_RESOLVER_H_