Remove the concept of threading from ProxyService, and move it into the Proxy...

chrome/browser/net/resolve_proxy_msg_helper_unittest.cc

 // Copyright (c) 2009 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 "chrome/browser/net/resolve_proxy_msg_helper.h"
 
 #include "base/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_resolver.h"
+#include "net/proxy/single_threaded_proxy_resolver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // This ProxyConfigService always returns "http://pac" as the PAC url to use.
 class MockProxyConfigService: public net::ProxyConfigService {
  public:
   virtual int GetProxyConfig(net::ProxyConfig* results) {
     results->pac_url = GURL("http://pac");
     return net::OK;
   }
 };
 
 // This PAC resolver always returns the hostname of the query URL as the
 // proxy to use. The Block() method will make GetProxyForURL() hang until
 // Unblock() is called.
-class MockProxyResolver : public net::ProxyResolver {
+class SyncMockProxyResolver : public net::ProxyResolver {
  public:
-  MockProxyResolver() : ProxyResolver(true), event_(false, false),
-                        is_blocked_(false) {
+  SyncMockProxyResolver() : ProxyResolver(false /*expects_pac_bytes*/),
+                            event_(false, false),
+                            is_blocked_(false) {
   }
 
   virtual int GetProxyForURL(const GURL& query_url,
-                             const GURL& /*pac_url*/,
-                             net::ProxyInfo* results) {
+                             net::ProxyInfo* results,
+                             net::CompletionCallback* callback,
+                             RequestHandle* request) {
     if (is_blocked_)
       event_.Wait();
     results->UseNamedProxy(query_url.host());
     return net::OK;
   }
 
+  virtual void CancelRequest(RequestHandle request) {
+    NOTREACHED();
+  }
+
+  virtual void SetPacScriptByUrlInternal(const GURL& pac_url) {}
+
   void Block() {
     is_blocked_ = true;
     event_.Reset();
   }
 
   void Unblock() {
     is_blocked_ = false;
     event_.Signal();
   }
 
  private:
   base::WaitableEvent event_;
   bool is_blocked_;
 };
 
+class MockProxyResolver : public net::SingleThreadedProxyResolver {
+ public:
+  MockProxyResolver()
+      : net::SingleThreadedProxyResolver(new SyncMockProxyResolver) {
+    x = reinterpret_cast<SyncMockProxyResolver*>(resolver());
+  }
+
+  // TODO(eroman): cleanup.
+  SyncMockProxyResolver* x;
+};
+
 // This struct holds the values that were passed to
 // Delegate::OnResolveProxyCompleted(). The caller should use WaitUntilDone()
 // to block until the result has been populated.
 struct ResultFuture {
  public:
   ResultFuture()
       : reply_msg(NULL),
         error_code(0),
         started_(false, false),
         completed_(false, false) {
@@ skipping 199 matching lines @@
 
   GURL url1("http://www.google1.com/");
   GURL url2("http://www.google2.com/");
   GURL url3("http://www.google3.com/");
 
   scoped_ptr<IPC::Message> msg1(new IPC::Message());
   scoped_ptr<IPC::Message> msg2(new IPC::Message());
   scoped_ptr<IPC::Message> msg3(new IPC::Message());
 
   // Make the proxy resolver hang on the next request.
-  runner.proxy_resolver()->Block();
+  runner.proxy_resolver()->x->Block();
 
   // Start three requests. Since the proxy resolver is hung, the second two
   // will be pending.
 
   scoped_ptr<ResultFuture> result1(runner.Start(url1, msg1.get()));
   scoped_ptr<ResultFuture> result2(runner.Start(url2, msg2.get()));
   scoped_ptr<ResultFuture> result3(runner.Start(url3, msg3.get()));
 
   // Wait for the final request to have been scheduled. Otherwise we may rush
   // to calling Unblock() without actually having blocked anything.
   result3->WaitUntilStarted();
 
   // Unblock the proxy service so requests 1-3 can complete.
-  runner.proxy_resolver()->Unblock();
+  runner.proxy_resolver()->x->Unblock();
 
   // Wait for all the requests to finish (they run in FIFO order).
   result3->WaitUntilDone();
 
   // Check that each call invoked the callback with the right parameters.
 
   EXPECT_EQ(msg1.get(), result1->reply_msg);
   EXPECT_EQ(net::OK, result1->error_code);
   EXPECT_EQ("PROXY www.google1.com:80", result1->proxy_list);
 
@@ skipping 14 matching lines @@
   GURL url2("http://www.google2.com/");
   GURL url3("http://www.google3.com/");
 
   // NOTE: these are not scoped ptr, since they will be deleted by the
   // request's cancellation.
   IPC::Message* msg1 = new IPC::Message();
   IPC::Message* msg2 = new IPC::Message();
   IPC::Message* msg3 = new IPC::Message();
 
   // Make the next request block.
-  runner.proxy_resolver()->Block();
+  runner.proxy_resolver()->x->Block();
 
   // Start three requests; since the first one blocked, the other two should
   // be pending.
 
   scoped_ptr<ResultFuture> result1(runner.Start(url1, msg1));
   scoped_ptr<ResultFuture> result2(runner.Start(url2, msg2));
   scoped_ptr<ResultFuture> result3(runner.Start(url3, msg3));
 
   result3->WaitUntilStarted();
 
   // Delete the underlying ResolveProxyMsgHelper -- this should cancel all
   // the requests which are outstanding.
   runner.DestroyAsyncRunner();
 
   // Unblocking the proxy resolver means the three requests can complete --
   // however they should not try to notify the delegate since we have already
   // deleted the helper.
-  runner.proxy_resolver()->Unblock();
+  runner.proxy_resolver()->x->Unblock();
 
   // Check that none of the requests were sent to the delegate.
   EXPECT_FALSE(
       result1->TimedWaitUntilDone(base::TimeDelta::FromMilliseconds(2)));
   EXPECT_FALSE(
       result2->TimedWaitUntilDone(base::TimeDelta::FromMilliseconds(2)));
   EXPECT_FALSE(
       result3->TimedWaitUntilDone(base::TimeDelta::FromMilliseconds(2)));
 
   // It should also be the case that msg1, msg2, msg3 were deleted by the
   // cancellation. (Else will show up as a leak in Purify).
 }