Add a MockAsyncProxyResolverFactory and update some tests to use it.

net/proxy/mock_proxy_resolver.h

Index: net/proxy/mock_proxy_resolver.h
diff --git a/net/proxy/mock_proxy_resolver.h b/net/proxy/mock_proxy_resolver.h
index ee24da41cec85c445873ccf874019aea4fab4cdb..efa3620bcd4fca7565bc7b907808415a57ce9933 100644
--- a/net/proxy/mock_proxy_resolver.h
+++ b/net/proxy/mock_proxy_resolver.h
@@ -124,20 +124,68 @@ class MockAsyncProxyResolverExpectsBytes : public MockAsyncProxyResolverBase {
       : MockAsyncProxyResolverBase(true /*expects_pac_bytes*/) {}
 };
 
-// This factory returns ProxyResolvers that forward all requests to
-// |resolver|. |resolver| must remain so long as any value returned from
-// CreateProxyResolver remains in use.
-class ForwardingProxyResolverFactory : public LegacyProxyResolverFactory {
+// Asynchronous mock proxy resolver factory . All requests complete
+// asynchronously; the user must call Request::CompleteNow() on a pending
+// request to signal it.
+class MockAsyncProxyResolverFactory : public ProxyResolverFactory {
  public:
-  explicit ForwardingProxyResolverFactory(ProxyResolver* resolver);
+  class Request;
+  using RequestsList = std::vector<scoped_refptr<Request>>;
 
-  // LegacyProxyResolverFactory override.
-  scoped_ptr<ProxyResolver> CreateProxyResolver() override;
+  explicit MockAsyncProxyResolverFactory(bool resolvers_expect_pac_bytes);
+  ~MockAsyncProxyResolverFactory() override;
+
+  int CreateProxyResolver(
+      const scoped_refptr<ProxyResolverScriptData>& pac_script,
+      scoped_ptr<ProxyResolver>* resolver,
+      const CompletionCallback& callback,
+      scoped_ptr<ProxyResolverFactory::Request>* request) override;
+
+  const RequestsList& pending_requests() const { return pending_requests_; }
+
+  const RequestsList& cancelled_requests() const { return cancelled_requests_; }
+
+  void RemovePendingRequest(Request* request);
+
+ private:
+  class Job;
+  RequestsList pending_requests_;
+  RequestsList cancelled_requests_;
+};
+
+class MockAsyncProxyResolverFactory::Request
+    : public base::RefCounted<Request> {
+ public:
+  Request(MockAsyncProxyResolverFactory* factory,
+          const scoped_refptr<ProxyResolverScriptData>& script_data,
+          scoped_ptr<ProxyResolver>* resolver,
+          const CompletionCallback& callback);
+
+  const scoped_refptr<ProxyResolverScriptData>& script_data() const {
+    return script_data_;
+  }
+
+  // Completes this request. A ForwardingProxyResolver that forwards to
+  // |resolver| will be returned to the requester. |resolver| must not be
+  // null and must remain as long as the resolver returned by this request
+  // remains in use.
+  void CompleteNowWithForwarder(int rv, ProxyResolver* resolver);
+
+  void CompleteNow(int rv, scoped_ptr<ProxyResolver> resolver);
 
  private:
-  ProxyResolver* resolver_;
+  friend class base::RefCounted<Request>;
+  friend class MockAsyncProxyResolverFactory;
+  friend class MockAsyncProxyResolverFactory::Job;
+
+  ~Request();
+
+  void FactoryDestroyed();
 
-  DISALLOW_COPY_AND_ASSIGN(ForwardingProxyResolverFactory);
+  MockAsyncProxyResolverFactory* factory_;
+  const scoped_refptr<ProxyResolverScriptData> script_data_;
+  scoped_ptr<ProxyResolver>* resolver_;
+  CompletionCallback callback_;
 };
 
 // ForwardingProxyResolver forwards all requests to |impl|. |impl| must remain