Add a MockAsyncProxyResolverFactory and update some tests to use it.

net/proxy/mock_proxy_resolver.h

 // Copyright (c) 2012 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_MOCK_PROXY_RESOLVER_H_
 #define NET_PROXY_MOCK_PROXY_RESOLVER_H_
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 106 matching lines @@
   MockAsyncProxyResolver()
       : MockAsyncProxyResolverBase(false /*expects_pac_bytes*/) {}
 };
 
 class MockAsyncProxyResolverExpectsBytes : public MockAsyncProxyResolverBase {
  public:
   MockAsyncProxyResolverExpectsBytes()
       : 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 : public base::RefCounted<Request> {
+   public:
+    Request(MockAsyncProxyResolverFactory* factory,
+            const scoped_refptr<ProxyResolverScriptData>& script_data,
+            scoped_ptr<ProxyResolver>* resolver,
+            const net::CompletionCallback& callback);
 
-  // LegacyProxyResolverFactory override.
-  scoped_ptr<ProxyResolver> CreateProxyResolver() override;
+    const ProxyResolverScriptData* script_data() const {

[eroman, 2015/04/22 16:30:38]

can you return a "const scoped_refptr<ProxyResolverScriptData>&" instead? Is
that better?

[Sam McNally, 2015/04/23 03:04:43]

Done.

+      return script_data_.get();
+    }
+
+    // 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:
+    friend class base::RefCounted<Request>;
+
+    ~Request();
+
+    MockAsyncProxyResolverFactory* factory_;
+    const scoped_refptr<ProxyResolverScriptData> script_data_;
+    scoped_ptr<ProxyResolver>* resolver_;
+    net::CompletionCallback callback_;
+  };
+
+  using RequestsList = std::vector<scoped_refptr<Request>>;
+
+  explicit MockAsyncProxyResolverFactory(bool resolvers_expect_pac_bytes);
+  ~MockAsyncProxyResolverFactory() override;
+
+  int CreateProxyResolver(
+      const scoped_refptr<ProxyResolverScriptData>& pac_script,
+      scoped_ptr<ProxyResolver>* resolver,
+      const net::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:
-  ProxyResolver* resolver_;
+  class Job;
+  RequestsList pending_requests_;
+  RequestsList cancelled_requests_;
+};
+
+// This factory forwards all calls to |impl|. |impl| must remain so long as this
+// remains in use.
+class ForwardingProxyResolverFactory : public ProxyResolverFactory {

[eroman, 2015/04/22 16:30:38]

Let's delete this. I don't think there is much value in forwarding a factory to
itself (see the comments in proxy_service_unittest.cc)

[Sam McNally, 2015/04/23 03:04:43]

Done.

+ public:
+  explicit ForwardingProxyResolverFactory(ProxyResolverFactory* impl);
+
+  // ProxyResolverFactory override.
+  int CreateProxyResolver(
+      const scoped_refptr<ProxyResolverScriptData>& pac_script,
+      scoped_ptr<ProxyResolver>* resolver,
+      const net::CompletionCallback& callback,
+      scoped_ptr<Request>* request) override;
+
+ private:
+  ProxyResolverFactory* impl_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardingProxyResolverFactory);
 };
 
 // ForwardingProxyResolver forwards all requests to |impl|. |impl| must remain
 // so long as this remains in use.
 class ForwardingProxyResolver : public ProxyResolver {
  public:
   explicit ForwardingProxyResolver(ProxyResolver* impl);
 
@@ skipping 11 matching lines @@
 
  private:
   ProxyResolver* impl_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardingProxyResolver);
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_MOCK_PROXY_RESOLVER_H_