Add a MockAsyncProxyResolverFactory and update some tests to use it.

net/proxy/multi_threaded_proxy_resolver_unittest.cc

 // 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.
 
 #include "net/proxy/multi_threaded_proxy_resolver.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 155 matching lines @@
   std::vector<BlockableProxyResolver*> resolvers() {
     return resolvers_;
   }
 
  private:
   std::vector<BlockableProxyResolver*> resolvers_;
 };
 
 TEST(MultiThreadedProxyResolverTest, SingleThread_Basic) {
   const size_t kNumThreads = 1u;
-  scoped_ptr<MockProxyResolver> mock(new MockProxyResolver);
-  MultiThreadedProxyResolver resolver(
-      new ForwardingProxyResolverFactory(mock.get()), kNumThreads);
+  BlockableProxyResolverFactory* factory = new BlockableProxyResolverFactory;
+  MultiThreadedProxyResolver resolver(factory, kNumThreads);
 
   int rv;
 
   EXPECT_TRUE(resolver.expects_pac_bytes());
 
   // Call SetPacScriptByData() -- verify that it reaches the synchronous
   // resolver.
   TestCompletionCallback set_script_callback;
   rv = resolver.SetPacScript(
       ProxyResolverScriptData::FromUTF8("pac script bytes"),
       set_script_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, set_script_callback.WaitForResult());
+  ASSERT_EQ(1u, factory->resolvers().size());
   EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
-            mock->last_script_data()->utf16());
+            factory->resolvers()[0]->last_script_data()->utf16());
 
   // Start request 0.
   TestCompletionCallback callback0;
   BoundTestNetLog log0;
   ProxyInfo results0;
   rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
                                callback0.callback(), NULL, log0.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait for request 0 to finish.
@@ skipping 45 matching lines @@
   rv = callback3.WaitForResult();
   EXPECT_EQ(3, rv);
   EXPECT_EQ("PROXY request3:80", results3.ToPacString());
 }
 
 // Tests that the NetLog is updated to include the time the request was waiting
 // to be scheduled to a thread.
 TEST(MultiThreadedProxyResolverTest,
      SingleThread_UpdatesNetLogWithThreadWait) {
   const size_t kNumThreads = 1u;
-  scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
-  MultiThreadedProxyResolver resolver(
-      new ForwardingProxyResolverFactory(mock.get()), kNumThreads);
+  BlockableProxyResolverFactory* factory = new BlockableProxyResolverFactory;
+  MultiThreadedProxyResolver resolver(factory, kNumThreads);
 
   int rv;
 
   // Initialize the resolver.
   TestCompletionCallback init_callback;
   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("foo"),
                              init_callback.callback());
   EXPECT_EQ(OK, init_callback.WaitForResult());
 
+  ASSERT_EQ(1u, factory->resolvers().size());
+  BlockableProxyResolver* mock = factory->resolvers()[0];
+
   // Block the proxy resolver, so no request can complete.
   mock->Block();
 
   // Start request 0.
   ProxyResolver::RequestHandle request0;
   TestCompletionCallback callback0;
   ProxyInfo results0;
   BoundTestNetLog log0;
   rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
                                callback0.callback(), &request0, log0.bound());
@@ skipping 61 matching lines @@
       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
   EXPECT_TRUE(LogContainsEndEvent(
       entries2, 1,
       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
 }
 
 // Cancel a request which is in progress, and then cancel a request which
 // is pending.
 TEST(MultiThreadedProxyResolverTest, SingleThread_CancelRequest) {
   const size_t kNumThreads = 1u;
-  scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
-  MultiThreadedProxyResolver resolver(
-      new ForwardingProxyResolverFactory(mock.get()),
-                                      kNumThreads);
+  BlockableProxyResolverFactory* factory = new BlockableProxyResolverFactory;
+  MultiThreadedProxyResolver resolver(factory, kNumThreads);
 
   int rv;
 
   // Initialize the resolver.
   TestCompletionCallback init_callback;
   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("foo"),
                              init_callback.callback());
   EXPECT_EQ(OK, init_callback.WaitForResult());
 
+  ASSERT_EQ(1u, factory->resolvers().size());
+  BlockableProxyResolver* mock = factory->resolvers()[0];
+
   // Block the proxy resolver, so no request can complete.
   mock->Block();
 
   // Start request 0.
   ProxyResolver::RequestHandle request0;
   TestCompletionCallback callback0;
   ProxyInfo results0;
   rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
                                callback0.callback(), &request0, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 44 matching lines @@
   // Requests 0 and 2 which were cancelled, hence their completion callbacks
   // were never summoned.
   EXPECT_FALSE(callback0.have_result());
   EXPECT_FALSE(callback2.have_result());
 }
 
 // Test that deleting MultiThreadedProxyResolver while requests are
 // outstanding cancels them (and doesn't leak anything).
 TEST(MultiThreadedProxyResolverTest, SingleThread_CancelRequestByDeleting) {
   const size_t kNumThreads = 1u;
-  scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
+  BlockableProxyResolverFactory* factory = new BlockableProxyResolverFactory;
   scoped_ptr<MultiThreadedProxyResolver> resolver(
-      new MultiThreadedProxyResolver(
-          new ForwardingProxyResolverFactory(mock.get()), kNumThreads));
+      new MultiThreadedProxyResolver(factory, kNumThreads));
 
   int rv;
 
   // Initialize the resolver.
   TestCompletionCallback init_callback;
   rv = resolver->SetPacScript(ProxyResolverScriptData::FromUTF8("foo"),
                               init_callback.callback());
   EXPECT_EQ(OK, init_callback.WaitForResult());
 
+  ASSERT_EQ(1u, factory->resolvers().size());
+  BlockableProxyResolver* mock = factory->resolvers()[0];
+
   // Block the proxy resolver, so no request can complete.
   mock->Block();
 
   // Start 3 requests.
 
   TestCompletionCallback callback0;
   ProxyInfo results0;
   rv = resolver->GetProxyForURL(GURL("http://request0"), &results0,
                                 callback0.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 30 matching lines @@
 
   // Check that none of the outstanding requests were completed.
   EXPECT_FALSE(callback0.have_result());
   EXPECT_FALSE(callback1.have_result());
   EXPECT_FALSE(callback2.have_result());
 }
 
 // Cancel an outstanding call to SetPacScriptByData().
 TEST(MultiThreadedProxyResolverTest, SingleThread_CancelSetPacScript) {
   const size_t kNumThreads = 1u;
-  scoped_ptr<BlockableProxyResolver> mock(new BlockableProxyResolver);
-  MultiThreadedProxyResolver resolver(
-      new ForwardingProxyResolverFactory(mock.get()), kNumThreads);
+  BlockableProxyResolverFactory* factory = new BlockableProxyResolverFactory;
+  MultiThreadedProxyResolver resolver(factory, kNumThreads);
 
   int rv;
 
   TestCompletionCallback set_pac_script_callback;
   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("data"),
                              set_pac_script_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
+  EXPECT_EQ(1u, factory->resolvers().size());
+
   // Cancel the SetPacScriptByData request.
   resolver.CancelSetPacScript();
 
   // Start another SetPacScript request
   TestCompletionCallback set_pac_script_callback2;
   rv = resolver.SetPacScript(ProxyResolverScriptData::FromUTF8("data2"),
                              set_pac_script_callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait for the initialization to complete.
 
   rv = set_pac_script_callback2.WaitForResult();
   EXPECT_EQ(0, rv);
-  EXPECT_EQ(ASCIIToUTF16("data2"), mock->last_script_data()->utf16());
+  ASSERT_EQ(2u, factory->resolvers().size());
+  EXPECT_EQ(ASCIIToUTF16("data2"),
+            factory->resolvers()[1]->last_script_data()->utf16());
 
   // The first SetPacScript callback should never have been completed.
   EXPECT_FALSE(set_pac_script_callback.have_result());
 }
 
 // Tests setting the PAC script once, lazily creating new threads, and
 // cancelling requests.
 TEST(MultiThreadedProxyResolverTest, ThreeThreads_Basic) {
   const size_t kNumThreads = 3u;
   BlockableProxyResolverFactory* factory = new BlockableProxyResolverFactory;
@@ skipping 167 matching lines @@
   // All in all, the first thread should have seen just 1 request. And the
   // second thread 3 requests.
   ASSERT_EQ(2u, factory->resolvers().size());
   EXPECT_EQ(1, factory->resolvers()[0]->request_count());
   EXPECT_EQ(3, factory->resolvers()[1]->request_count());
 }
 
 }  // namespace
 
 }  // namespace net