Add a MockAsyncProxyResolverFactory and update some tests to use it.

content/browser/resolve_proxy_msg_helper_unittest.cc

 // Copyright (c) 2011 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 "content/browser/resolve_proxy_msg_helper.h"
 
 #include "content/browser/browser_thread_impl.h"
 #include "content/common/view_messages.h"
 #include "ipc/ipc_test_sink.h"
 #include "net/base/net_errors.h"
@@ skipping 40 matching lines @@
     PendingResult(bool result,
                   const std::string& proxy_list)
         : result(result), proxy_list(proxy_list) {
     }
 
     bool result;
     std::string proxy_list;
   };
 
   ResolveProxyMsgHelperTest()
-      : service_(new net::ProxyService(
+      : resolver_factory_(false),
+        service_(new net::ProxyService(
             new MockProxyConfigService,
             make_scoped_ptr(
-                new net::ForwardingProxyResolverFactory(&resolver_)),
+                new net::ForwardingProxyResolverFactory(&resolver_factory_)),
             NULL)),
         helper_(new TestResolveProxyMsgHelper(service_.get(), this)),
         io_thread_(BrowserThread::IO, &message_loop_) {
     test_sink_.AddFilter(this);
   }
 
  protected:
   const PendingResult* pending_result() const { return pending_result_.get(); }
 
   void clear_pending_result() {
     pending_result_.reset();
   }
 
   IPC::Message* GenerateReply() {
     bool temp_bool;
     std::string temp_string;
     ViewHostMsg_ResolveProxy message(GURL(), &temp_bool, &temp_string);
     return IPC::SyncMessage::GenerateReply(&message);
   }
 
+  net::MockAsyncProxyResolverFactory resolver_factory_;
   net::MockAsyncProxyResolver resolver_;
   scoped_ptr<net::ProxyService> service_;
   scoped_refptr<ResolveProxyMsgHelper> helper_;
   scoped_ptr<PendingResult> pending_result_;
 
  private:
   bool OnMessageReceived(const IPC::Message& msg) override {
     TupleTypes<ViewHostMsg_ResolveProxy::ReplyParam>::ValueTuple reply_data;
     EXPECT_TRUE(ViewHostMsg_ResolveProxy::ReadReplyParam(&msg, &reply_data));
     DCHECK(!pending_result_.get());
@@ skipping 18 matching lines @@
   IPC::Message* msg1 = GenerateReply();
   IPC::Message* msg2 = GenerateReply();
   IPC::Message* msg3 = GenerateReply();
 
   // Execute each request sequentially (so there are never 2 requests
   // outstanding at the same time).
 
   helper_->OnResolveProxy(url1, msg1);
 
   // Finish ProxyService's initialization.
-  resolver_.pending_set_pac_script_request()->CompleteNow(net::OK);
+  ASSERT_EQ(1u, resolver_factory_.pending_requests().size());
+  resolver_factory_.pending_requests()[0]->CompleteNowWithForwarder(net::OK,
+                                                                    &resolver_);
 
   ASSERT_EQ(1u, resolver_.pending_requests().size());
   EXPECT_EQ(url1, resolver_.pending_requests()[0]->url());
   resolver_.pending_requests()[0]->results()->UseNamedProxy("result1:80");
   resolver_.pending_requests()[0]->CompleteNow(net::OK);
 
   // Check result.
   EXPECT_EQ(true, pending_result()->result);
   EXPECT_EQ("PROXY result1:80", pending_result()->proxy_list);
   clear_pending_result();
@@ skipping 32 matching lines @@
   IPC::Message* msg1 = GenerateReply();
   IPC::Message* msg2 = GenerateReply();
   IPC::Message* msg3 = GenerateReply();
 
   // Start three requests. Since the proxy resolver is async, all the
   // requests will be pending.
 
   helper_->OnResolveProxy(url1, msg1);
 
   // Finish ProxyService's initialization.
-  resolver_.pending_set_pac_script_request()->CompleteNow(net::OK);
+  ASSERT_EQ(1u, resolver_factory_.pending_requests().size());
+  resolver_factory_.pending_requests()[0]->CompleteNowWithForwarder(net::OK,
+                                                                    &resolver_);
 
   helper_->OnResolveProxy(url2, msg2);
   helper_->OnResolveProxy(url3, msg3);
 
   // ResolveProxyHelper only keeps 1 request outstanding in ProxyService
   // at a time.
   ASSERT_EQ(1u, resolver_.pending_requests().size());
   EXPECT_EQ(url1, resolver_.pending_requests()[0]->url());
 
   resolver_.pending_requests()[0]->results()->UseNamedProxy("result1:80");
@@ skipping 37 matching lines @@
   IPC::Message* msg1 = GenerateReply();
   IPC::Message* msg2 = GenerateReply();
   IPC::Message* msg3 = GenerateReply();
 
   // Start three requests. Since the proxy resolver is async, all the
   // requests will be pending.
 
   helper_->OnResolveProxy(url1, msg1);
 
   // Finish ProxyService's initialization.
-  resolver_.pending_set_pac_script_request()->CompleteNow(net::OK);
+  ASSERT_EQ(1u, resolver_factory_.pending_requests().size());
+  resolver_factory_.pending_requests()[0]->CompleteNowWithForwarder(net::OK,
+                                                                    &resolver_);
 
   helper_->OnResolveProxy(url2, msg2);
   helper_->OnResolveProxy(url3, msg3);
 
   // ResolveProxyHelper only keeps 1 request outstanding in ProxyService
   // at a time.
   ASSERT_EQ(1u, resolver_.pending_requests().size());
   EXPECT_EQ(url1, resolver_.pending_requests()[0]->url());
 
   // Delete the underlying ResolveProxyMsgHelper -- this should cancel all
   // the requests which are outstanding.
   helper_ = NULL;
 
   // The pending requests sent to the proxy resolver should have been cancelled.
 
   EXPECT_EQ(0u, resolver_.pending_requests().size());
 
   EXPECT_TRUE(pending_result() == NULL);
 
   // It should also be the case that msg1, msg2, msg3 were deleted by the
   // cancellation. (Else will show up as a leak in Valgrind).
 }
 
 }  // namespace content