Add a MockAsyncProxyResolverFactory and update some tests to use it.

net/proxy/mock_proxy_resolver.cc

Index: net/proxy/mock_proxy_resolver.cc
diff --git a/net/proxy/mock_proxy_resolver.cc b/net/proxy/mock_proxy_resolver.cc
index 2ff09007eb116822b819dfa78806771987a5b7bd..06a890b5451a68874cf87f2a9d289e551419d18f 100644
--- a/net/proxy/mock_proxy_resolver.cc
+++ b/net/proxy/mock_proxy_resolver.cc
@@ -112,6 +112,93 @@ void MockAsyncProxyResolverBase::RemovePendingSetPacScriptRequest(
 MockAsyncProxyResolverBase::MockAsyncProxyResolverBase(bool expects_pac_bytes)
     : ProxyResolver(expects_pac_bytes) {}
 
+MockAsyncProxyResolverFactory::Request::Request(
+    MockAsyncProxyResolverFactory* factory,
+    const scoped_refptr<ProxyResolverScriptData>& script_data,
+    scoped_ptr<ProxyResolver>* resolver,
+    const CompletionCallback& callback)
+    : factory_(factory),
+      script_data_(script_data),
+      resolver_(resolver),
+      callback_(callback) {
+}
+
+MockAsyncProxyResolverFactory::Request::~Request() {
+}
+
+void MockAsyncProxyResolverFactory::Request::CompleteNow(
+    int rv,
+    scoped_ptr<ProxyResolver> resolver) {
+  *resolver_ = resolver.Pass();
+
+  // RemovePendingRequest may remove the last external reference to |this|.
+  scoped_refptr<MockAsyncProxyResolverFactory::Request> keep_alive(this);
+  factory_->RemovePendingRequest(this);
+  factory_ = nullptr;
+  callback_.Run(rv);
+}
+
+void MockAsyncProxyResolverFactory::Request::CompleteNowWithForwarder(
+    int rv,
+    ProxyResolver* resolver) {
+  DCHECK(resolver);
+  CompleteNow(rv, make_scoped_ptr(new ForwardingProxyResolver(resolver)));
+}
+
+void MockAsyncProxyResolverFactory::Request::FactoryDestroyed() {
+  factory_ = nullptr;
+}
+
+class MockAsyncProxyResolverFactory::Job
+    : public ProxyResolverFactory::Request {
+ public:
+  explicit Job(
+      const scoped_refptr<MockAsyncProxyResolverFactory::Request>& request)
+      : request_(request) {}
+  ~Job() override {
+    if (request_->factory_) {
+      request_->factory_->cancelled_requests_.push_back(request_);
+      request_->factory_->RemovePendingRequest(request_.get());
+    }
+  }
+
+ private:
+  scoped_refptr<MockAsyncProxyResolverFactory::Request> request_;
+};
+
+MockAsyncProxyResolverFactory::MockAsyncProxyResolverFactory(
+    bool resolvers_expect_pac_bytes)
+    : ProxyResolverFactory(resolvers_expect_pac_bytes) {
+}
+
+int MockAsyncProxyResolverFactory::CreateProxyResolver(
+    const scoped_refptr<ProxyResolverScriptData>& pac_script,
+    scoped_ptr<ProxyResolver>* resolver,
+    const net::CompletionCallback& callback,
+    scoped_ptr<ProxyResolverFactory::Request>* request_handle) {
+  scoped_refptr<Request> request =
+      new Request(this, pac_script, resolver, callback);
+  pending_requests_.push_back(request);
+
+  request_handle->reset(new Job(request));
+
+  // Test code completes the request by calling request->CompleteNow().
+  return ERR_IO_PENDING;
+}
+
+void MockAsyncProxyResolverFactory::RemovePendingRequest(Request* request) {
+  RequestsList::iterator it =
+      std::find(pending_requests_.begin(), pending_requests_.end(), request);
+  DCHECK(it != pending_requests_.end());
+  pending_requests_.erase(it);
+}
+
+MockAsyncProxyResolverFactory::~MockAsyncProxyResolverFactory() {
+  for (auto& request : pending_requests_) {
+    request->FactoryDestroyed();
+  }
+}
+
 ForwardingProxyResolver::ForwardingProxyResolver(ProxyResolver* impl)
     : ProxyResolver(impl->expects_pac_bytes()), impl_(impl) {
 }
@@ -142,15 +229,4 @@ int ForwardingProxyResolver::SetPacScript(
   return impl_->SetPacScript(script_data, callback);
 }
 
-ForwardingProxyResolverFactory::ForwardingProxyResolverFactory(
-    ProxyResolver* resolver)
-    : LegacyProxyResolverFactory(resolver->expects_pac_bytes()),
-      resolver_(resolver) {
-}
-
-scoped_ptr<ProxyResolver>
-ForwardingProxyResolverFactory::CreateProxyResolver() {
-  return make_scoped_ptr(new ForwardingProxyResolver(resolver_));
-}
-
 }  // namespace net