Add a MockAsyncProxyResolverFactory and update some tests to use it.

net/proxy/proxy_resolver_factory_unittest.cc

 // Copyright 2015 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/proxy_resolver_factory.h"
 
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/proxy/mock_proxy_resolver.h"
 #include "net/proxy/proxy_resolver.h"
@@ skipping 23 matching lines @@
     error_to_return_ = error;
   }
 
  private:
   bool synchronous_ = false;
   Error error_to_return_ = OK;
 };
 
 class TestLegacyProxyResolverFactory : public LegacyProxyResolverFactory {
  public:
-  TestLegacyProxyResolverFactory() : LegacyProxyResolverFactory(false) {}
+  using ProxyResolverFactory::CreateProxyResolver;
+
+  explicit TestLegacyProxyResolverFactory(ProxyResolver* resolver)
+      : LegacyProxyResolverFactory(false), resolver_(resolver) {}
 
   // LegacyProxyResolverFactory override.
   scoped_ptr<ProxyResolver> CreateProxyResolver() override {
-    return make_scoped_ptr(new ForwardingProxyResolver(&resolver_));
+    return make_scoped_ptr(new ForwardingProxyResolver(resolver_));
   }
 
-  TestProxyResolver& resolver() { return resolver_; }
-
  private:
-  TestProxyResolver resolver_;
+  ProxyResolver* resolver_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLegacyProxyResolverFactory);
 };
 
 }  // namespace
 
 class LegacyProxyResolverFactoryTest : public testing::Test {
  public:
-  ProxyResolverFactory& factory() { return factory_; }
-  TestProxyResolver& mock_resolver() { return factory_.resolver(); }
+  void SetUp() override {
+    factory_.reset(new TestLegacyProxyResolverFactory(&resolver_));
+  }
+
+  ProxyResolverFactory& factory() { return *factory_; }
+  TestProxyResolver& mock_resolver() { return resolver_; }
 
  private:
-  TestLegacyProxyResolverFactory factory_;
+  TestProxyResolver resolver_;
+  scoped_ptr<TestLegacyProxyResolverFactory> factory_;
 };
 
 TEST_F(LegacyProxyResolverFactoryTest, Async_Success) {
   const GURL url("http://proxy");
   TestCompletionCallback callback;
   scoped_ptr<ProxyResolver> resolver;
   scoped_ptr<ProxyResolverFactory::Request> request;
   EXPECT_EQ(ERR_IO_PENDING, factory().CreateProxyResolver(
                                 ProxyResolverScriptData::FromURL(url),
                                 &resolver, callback.callback(), &request));
@@ skipping 31 matching lines @@
                                 ProxyResolverScriptData::FromURL(url),
                                 &resolver, base::Bind(&Fail), &request));
   ASSERT_TRUE(mock_resolver().has_pending_set_pac_script_request());
   EXPECT_EQ(
       url,
       mock_resolver().pending_set_pac_script_request()->script_data()->url());
   request.reset();
   EXPECT_FALSE(resolver);
 }
 
+TEST_F(LegacyProxyResolverFactoryTest, Async_DeleteFactory) {
+  const GURL url("http://proxy");
+  scoped_ptr<ProxyResolver> resolver;
+  scoped_ptr<ProxyResolverFactory::Request> request;
+  {
+    TestProxyResolver test_resolver;
+    TestLegacyProxyResolverFactory factory(&test_resolver);
+    EXPECT_EQ(ERR_IO_PENDING, factory.CreateProxyResolver(
+                                  ProxyResolverScriptData::FromURL(url),
+                                  &resolver, base::Bind(&Fail), &request));
+    ASSERT_TRUE(test_resolver.has_pending_set_pac_script_request());
+    EXPECT_EQ(
+        url,
+        test_resolver.pending_set_pac_script_request()->script_data()->url());
+  }
+  EXPECT_FALSE(resolver);
+}
+
 TEST_F(LegacyProxyResolverFactoryTest, Sync_Success) {
   const GURL url("http://proxy");
   TestCompletionCallback callback;
   scoped_ptr<ProxyResolver> resolver;
   scoped_ptr<ProxyResolverFactory::Request> request;
   mock_resolver().set_error_to_return(OK);
   EXPECT_EQ(OK, factory().CreateProxyResolver(
                     ProxyResolverScriptData::FromURL(url), &resolver,
                     callback.callback(), &request));
   ASSERT_TRUE(mock_resolver().has_pending_set_pac_script_request());
@@ skipping 13 matching lines @@
                             ProxyResolverScriptData::FromURL(url), &resolver,
                             callback.callback(), &request));
   ASSERT_TRUE(mock_resolver().has_pending_set_pac_script_request());
   EXPECT_EQ(
       url,
       mock_resolver().pending_set_pac_script_request()->script_data()->url());
   EXPECT_FALSE(resolver);
 }
 
 }  // namespace net