Revert 108910 - Remove HostResolverImpl from Mock*HostResolver.

MockHostResolver should not depend on the job dispatch machinery of
HostResolverImpl. This implementation aims to be more readable/reliable
while providing the same testing utility.

MockHostResolver does not use extra threads hence cannot support 
WaitingHostResolverProc. To mock slow resolution, HangingHostResolver is
provided for unit_tests:PredictorTest.

Updated host_resolver_impl_unittest to test HostResolverImpl directly
(rather than through MockHostResolver).

BUG=99889
TEST=./net_unittests ; ./unit_tests --gtest_filter='PredictorTest.*' ; ./jingle_unittests


Review URL: http://codereview.chromium.org/8267001

TBR=szym@chromium.org
Review URL: http://codereview.chromium.org/8491023

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@108922 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 186 insertions, 308 deletions

diff --git a/net/base/host_resolver_impl_unittest.cc b/net/base/host_resolver_impl_unittest.cc
index 2922758..df38919 100644
--- a/net/base/host_resolver_impl_unittest.cc
+++ b/net/base/host_resolver_impl_unittest.cc
@@ -401,47 +401,6 @@ TEST_F(HostResolverImplTest, AsynchronousLookup) {
   EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr);
 }
 
-
-// Using WaitingHostResolverProc you can simulate very long lookups.
-class WaitingHostResolverProc : public HostResolverProc {
- public:
-  explicit WaitingHostResolverProc(HostResolverProc* previous)
-    : HostResolverProc(previous),
-      is_waiting_(false, false),
-      is_signaled_(false, false) {}
-
-  // Waits until a call to |Resolve| is blocked. It is recommended to always
-  // |Wait| before |Signal|, and required if issuing a series of two or more
-  // calls to |Signal|, because |WaitableEvent| does not count the number of
-  // signals.
-  void Wait() {
-    is_waiting_.Wait();
-  }
-
-  // Signals a waiting call to |Resolve|.
-  void Signal() {
-    is_signaled_.Signal();
-  }
-
-  // HostResolverProc methods:
-  virtual int Resolve(const std::string& host,
-                      AddressFamily address_family,
-                      HostResolverFlags host_resolver_flags,
-                      AddressList* addrlist,
-                      int* os_error) {
-    is_waiting_.Signal();
-    is_signaled_.Wait();
-    return ResolveUsingPrevious(host, address_family, host_resolver_flags,
-                                addrlist, os_error);
-  }
-
- private:
-  virtual ~WaitingHostResolverProc() {}
-
-  base::WaitableEvent is_waiting_;
-  base::WaitableEvent is_signaled_;
-};
-
 TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) {
   scoped_refptr<WaitingHostResolverProc> resolver_proc(
       new WaitingHostResolverProc(NULL));
@@ -463,7 +422,11 @@ TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) {
                                      log.bound());
     EXPECT_EQ(ERR_IO_PENDING, err);
 
-    resolver_proc->Wait();
+    // Make sure we will exit the queue even when callback is not called.
+    MessageLoop::current()->PostDelayedTask(FROM_HERE,
+                                            new MessageLoop::QuitTask(),
+                                            1000);
+    MessageLoop::current()->Run();
   }
 
   resolver_proc->Signal();
@@ -790,7 +753,8 @@ TEST_F(HostResolverImplTest, CancelWithinCallback) {
   scoped_refptr<CapturingHostResolverProc> resolver_proc(
       new CapturingHostResolverProc(NULL));
 
-  scoped_ptr<HostResolver> host_resolver(CreateHostResolverImpl(resolver_proc));
+  scoped_ptr<HostResolver> host_resolver(
+      CreateHostResolverImpl(resolver_proc));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
@@ -849,7 +813,8 @@ TEST_F(HostResolverImplTest, DeleteWithinCallback) {
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened. Note that the verifier holds the
   // only reference to |host_resolver|, so it can delete it within callback.
-  HostResolver* host_resolver = CreateHostResolverImpl(resolver_proc);
+  HostResolver* host_resolver =
+      CreateHostResolverImpl(resolver_proc);
   DeleteWithinCallbackVerifier verifier(host_resolver);
 
   // Start 4 requests, duplicating hosts "a". Since the resolver_proc is
@@ -1174,7 +1139,10 @@ TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
 TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) {
   scoped_refptr<WaitingHostResolverProc> resolver_proc(
       new WaitingHostResolverProc(NULL));
-  scoped_ptr<HostResolver> host_resolver(CreateHostResolverImpl(resolver_proc));
+  HostCache* cache = HostCache::CreateDefaultCache();
+  scoped_ptr<HostResolver> host_resolver(
+      new HostResolverImpl(resolver_proc, cache, kMaxJobs, kMaxRetryAttempts,
+                           NULL));
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
@@ -1184,23 +1152,21 @@ TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) {
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  resolver_proc->Wait();
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunAllPending();  // Notification happens async.
   resolver_proc->Signal();
 
   EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
-  EXPECT_EQ(0u, host_resolver->GetHostCache()->size());
+  EXPECT_EQ(0u, cache->size());
 }
 
 // Obey pool constraints after IP address has changed.
 TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
   scoped_refptr<WaitingHostResolverProc> resolver_proc(
-      new WaitingHostResolverProc(CreateCatchAllHostResolverProc()));
-  scoped_ptr<HostResolverImpl> host_resolver(
-      new HostResolverImpl(resolver_proc, HostCache::CreateDefaultCache(),
-                           kMaxJobs, kMaxRetryAttempts, NULL));
+      new WaitingHostResolverProc(NULL));
+  scoped_ptr<MockHostResolver> host_resolver(new MockHostResolver());
+  host_resolver->Reset(resolver_proc);
 
   const size_t kMaxOutstandingJobs = 1u;
   const size_t kMaxPendingRequests = 1000000u;  // not relevant.
@@ -1216,9 +1182,6 @@ TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  // Must wait before signal to ensure that the two signals don't get merged
-  // together. (Worker threads might not start until the last WaitForResult.)
-  resolver_proc->Wait();
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunAllPending();  // Notification happens async.
@@ -1226,25 +1189,30 @@ TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
 
   EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
 
+  // Don't bother with WaitingHostResolverProc anymore.
+  host_resolver->Reset(NULL);
+
   rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  resolver_proc->Wait();
-  resolver_proc->Signal();
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 class ResolveWithinCallback : public CallbackRunner< Tuple1<int> > {
  public:
-  explicit ResolveWithinCallback(const HostResolver::RequestInfo& info)
-      : info_(info) {}
+  ResolveWithinCallback(
+      MockHostResolver* host_resolver,
+      const HostResolver::RequestInfo& info)
+      : host_resolver_(host_resolver),
+        info_(info) {
+    DCHECK(host_resolver);
+  }
 
   virtual void RunWithParams(const Tuple1<int>& params) {
     // Ditch the WaitingHostResolverProc so that the subsequent request
     // succeeds.
+    host_resolver_->Reset(NULL);
     callback_.RunWithParams(params);
-    host_resolver_.reset(
-        CreateHostResolverImpl(CreateCatchAllHostResolverProc()));
     EXPECT_EQ(ERR_IO_PENDING,
               host_resolver_->Resolve(info_, &addrlist_, &nested_callback_,
                                       NULL, BoundNetLog()));
@@ -1259,32 +1227,33 @@ class ResolveWithinCallback : public CallbackRunner< Tuple1<int> > {
   }
 
  private:
+  MockHostResolver* const host_resolver_;
   const HostResolver::RequestInfo info_;
   AddressList addrlist_;
   TestOldCompletionCallback callback_;
   TestOldCompletionCallback nested_callback_;
-  scoped_ptr<HostResolver> host_resolver_;
 };
 
 TEST_F(HostResolverImplTest, OnlyAbortExistingRequestsOnIPAddressChange) {
   scoped_refptr<WaitingHostResolverProc> resolver_proc(
-      new WaitingHostResolverProc(CreateCatchAllHostResolverProc()));
-  scoped_ptr<HostResolver> host_resolver(CreateHostResolverImpl(resolver_proc));
+      new WaitingHostResolverProc(NULL));
+  scoped_ptr<MockHostResolver> host_resolver(new MockHostResolver());
+  host_resolver->Reset(resolver_proc);
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
-  ResolveWithinCallback callback(info);
+  ResolveWithinCallback callback(host_resolver.get(), info);
   AddressList addrlist;
   int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  resolver_proc->Wait();
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunAllPending();  // Notification happens async.
+
   EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
-  resolver_proc->Signal();  // release the thread from WorkerPool for cleanup
+  resolver_proc->Signal();
   EXPECT_EQ(OK, callback.WaitForNestedResult());
 }
 
diff --git a/net/base/mapped_host_resolver_unittest.cc b/net/base/mapped_host_resolver_unittest.cc
index e24fca3..8144b5c 100644
--- a/net/base/mapped_host_resolver_unittest.cc
+++ b/net/base/mapped_host_resolver_unittest.cc
@@ -1,10 +1,9 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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/base/mapped_host_resolver.h"
 
-#include "net/base/address_list.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
diff --git a/net/base/mock_host_resolver.cc b/net/base/mock_host_resolver.cc
index 87cb408..2e38dd9 100644
--- a/net/base/mock_host_resolver.cc
+++ b/net/base/mock_host_resolver.cc
@@ -4,15 +4,10 @@
 
 #include "net/base/mock_host_resolver.h"
 
-#include "base/bind.h"
-#include "base/location.h"
 #include "base/memory/ref_counted.h"
-#include "base/message_loop.h"
-#include "base/stl_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/threading/platform_thread.h"
-#include "net/base/host_cache.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
@@ -30,11 +25,13 @@ char* do_strdup(const char* src) {
 #endif
 }
 
-}  // namespace
-
-int ParseAddressList(const std::string& host_list,
-                     const std::string& canonical_name,
-                     AddressList* addrlist) {
+// Fills |*addrlist| with a socket address for |host_list| which should be a
+// comma-separated list of IPv4 or IPv6 literal(s) without enclosing brackets.
+// If |canonical_name| is non-empty it is used as the DNS canonical name for
+// the host. Returns OK on success, ERR_UNEXPECTED otherwise.
+int CreateIPAddressList(const std::string& host_list,
+                        const std::string& canonical_name,
+                        AddressList* addrlist) {
   *addrlist = AddressList();
   std::vector<std::string> addresses;
   base::SplitString(host_list, ',', &addresses);
@@ -57,156 +54,85 @@ int ParseAddressList(const std::string& host_list,
   return OK;
 }
 
-struct MockHostResolverBase::Request {
-  Request(const RequestInfo& req_info,
-          AddressList* addr,
-          OldCompletionCallback* cb)
-      : info(req_info), addresses(addr), callback(cb) {}
-  RequestInfo info;
-  AddressList* addresses;
-  OldCompletionCallback* callback;
-};
+}  // namespace
+
+MockHostResolverBase::~MockHostResolverBase() {}
+
+void MockHostResolverBase::Reset(HostResolverProc* interceptor) {
+  synchronous_mode_ = false;
+
+  // At the root of the chain, map everything to localhost.
+  scoped_refptr<RuleBasedHostResolverProc> catchall(
+      new RuleBasedHostResolverProc(NULL));
+#if defined(OS_ANDROID)
+  // In Android emulator, the development machine's '127.0.0.1' is mapped to
+  // '10.0.2.2'.
+  catchall->AddRule("*", "10.0.2.2");
+#else
+  catchall->AddRule("*", "127.0.0.1");
+#endif
+
+  // Next add a rules-based layer the use controls.
+  rules_ = new RuleBasedHostResolverProc(catchall);
 
-MockHostResolverBase::~MockHostResolverBase() {
-  STLDeleteValues(&requests_);
+  HostResolverProc* proc = rules_;
+
+  // Lastly add the provided interceptor to the front of the chain.
+  if (interceptor) {
+    interceptor->SetPreviousProc(proc);
+    proc = interceptor;
+  }
+
+  HostCache* cache = NULL;
+
+  if (use_caching_) {
+    cache = new HostCache(
+        100,  // max entries.
+        base::TimeDelta::FromMinutes(1),
+        base::TimeDelta::FromSeconds(0));
+  }
+
+  impl_.reset(new HostResolverImpl(proc, cache, 50u, 4u, NULL));
 }
 
 int MockHostResolverBase::Resolve(const RequestInfo& info,
                                   AddressList* addresses,
                                   OldCompletionCallback* callback,
-                                  RequestHandle* handle,
+                                  RequestHandle* out_req,
                                   const BoundNetLog& net_log) {
-  DCHECK(CalledOnValidThread());
-  size_t id = next_request_id_++;
-  FOR_EACH_OBSERVER(Observer, observers_, OnStartResolution(id, info));
-  int rv = ResolveFromIPLiteralOrCache(info, addresses);
-  if (rv != ERR_DNS_CACHE_MISS) {
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnFinishResolutionWithStatus(id, rv == OK, info));
-    return rv;
-  }
   if (synchronous_mode_) {
-    return ResolveProc(id, info, addresses);
+    TestOldCompletionCallback sync_callback;
+    int rv = impl_->Resolve(info, addresses, &sync_callback, out_req, net_log);
+    if (rv == ERR_IO_PENDING) {
+      MessageLoop::ScopedNestableTaskAllower nestable(MessageLoop::current());
+      return sync_callback.WaitForResult();
+    }
+    return rv;
   }
-  // Store the request for asynchronous resolution
-  Request* req = new Request(info, addresses, callback);
-  requests_[id] = req;
-  if (handle)
-    *handle = reinterpret_cast<RequestHandle>(id);
-  MessageLoop::current()->PostTask(FROM_HERE,
-                                   base::Bind(&MockHostResolverBase::ResolveNow,
-                                              AsWeakPtr(),
-                                              id));
-  return ERR_IO_PENDING;
+  return impl_->Resolve(info, addresses, callback, out_req, net_log);
 }
 
 int MockHostResolverBase::ResolveFromCache(const RequestInfo& info,
                                            AddressList* addresses,
                                            const BoundNetLog& net_log) {
-  DCHECK(CalledOnValidThread());
-  size_t id = next_request_id_++;
-  FOR_EACH_OBSERVER(Observer, observers_, OnStartResolution(id, info));
-  int rv = ResolveFromIPLiteralOrCache(info, addresses);
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    OnFinishResolutionWithStatus(id, rv == OK, info));
-  return rv;
+  return impl_->ResolveFromCache(info, addresses, net_log);
 }
 
-void MockHostResolverBase::CancelRequest(RequestHandle handle) {
-  DCHECK(CalledOnValidThread());
-  size_t id = reinterpret_cast<size_t>(handle);
-  RequestMap::iterator it = requests_.find(id);
-  if (it != requests_.end()) {
-    scoped_ptr<Request> req(it->second);
-    requests_.erase(it);
-    FOR_EACH_OBSERVER(Observer, observers_, OnCancelResolution(id, req->info));
-  }
+void MockHostResolverBase::CancelRequest(RequestHandle req) {
+  impl_->CancelRequest(req);
 }
 
 void MockHostResolverBase::AddObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.AddObserver(observer);
+  impl_->AddObserver(observer);
 }
 
 void MockHostResolverBase::RemoveObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.RemoveObserver(observer);
+  impl_->RemoveObserver(observer);
 }
 
-HostCache* MockHostResolverBase::GetHostCache() {
-  return cache_.get();
-}
-
-// start id from 1 to distinguish from NULL RequestHandle
 MockHostResolverBase::MockHostResolverBase(bool use_caching)
-    : synchronous_mode_(false), next_request_id_(1) {
-  rules_ = CreateCatchAllHostResolverProc();
-  proc_ = rules_;
-
-  if (use_caching) {
-    cache_.reset(new HostCache(
-        100,  // max entries.
-        base::TimeDelta::FromMinutes(1),
-        base::TimeDelta::FromSeconds(0)));
-  }
-  STLDeleteValues(&requests_);
-}
-
-int MockHostResolverBase::ResolveFromIPLiteralOrCache(const RequestInfo& info,
-                                                      AddressList* addresses) {
-  IPAddressNumber ip;
-  if (ParseIPLiteralToNumber(info.hostname(), &ip)) {
-    *addresses = AddressList::CreateFromIPAddressWithCname(
-        ip, info.port(), info.host_resolver_flags() & HOST_RESOLVER_CANONNAME);
-    return OK;
-  }
-  int rv = ERR_DNS_CACHE_MISS;
-  if (cache_.get() && info.allow_cached_response()) {
-    HostCache::Key key(info.hostname(),
-                       info.address_family(),
-                       info.host_resolver_flags());
-    const HostCache::Entry* entry = cache_->Lookup(key, base::TimeTicks::Now());
-    if (entry) {
-      rv = entry->error;
-      if (rv == OK)
-        *addresses = CreateAddressListUsingPort(entry->addrlist, info.port());
-    }
-  }
-  return rv;
-}
-
-int MockHostResolverBase::ResolveProc(size_t id,
-                                      const RequestInfo& info,
-                                      AddressList* addresses) {
-  AddressList addr;
-  int rv = proc_->Resolve(info.hostname(),
-                          info.address_family(),
-                          info.host_resolver_flags(),
-                          &addr,
-                          NULL);
-  if (cache_.get()) {
-    HostCache::Key key(info.hostname(),
-                       info.address_family(),
-                       info.host_resolver_flags());
-    cache_->Set(key, rv, addr, base::TimeTicks::Now());
-  }
-  if (rv == OK)
-    *addresses = CreateAddressListUsingPort(addr, info.port());
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    OnFinishResolutionWithStatus(id, rv == OK, info));
-  return rv;
-}
-
-void MockHostResolverBase::ResolveNow(size_t id) {
-  RequestMap::iterator it = requests_.find(id);
-  if (it == requests_.end())
-    return;  // was canceled
-
-  scoped_ptr<Request> req(it->second);
-  requests_.erase(it);
-  int rv = ResolveProc(id, req->info, req->addresses);
-  if (req->callback)
-    req->callback->Run(rv);
+    : use_caching_(use_caching) {
+  Reset(NULL);
 }
 
 //-----------------------------------------------------------------------------
@@ -347,9 +273,9 @@ int RuleBasedHostResolverProc::Resolve(const std::string& host,
                                         host_resolver_flags,
                                         addrlist, os_error);
         case Rule::kResolverTypeIPLiteral:
-          return ParseAddressList(effective_host,
-                                  r->canonical_name,
-                                  addrlist);
+          return CreateIPAddressList(effective_host,
+                                     r->canonical_name,
+                                     addrlist);
         default:
           NOTREACHED();
           return ERR_UNEXPECTED;
@@ -363,36 +289,27 @@ int RuleBasedHostResolverProc::Resolve(const std::string& host,
 RuleBasedHostResolverProc::~RuleBasedHostResolverProc() {
 }
 
-RuleBasedHostResolverProc* CreateCatchAllHostResolverProc() {
-  RuleBasedHostResolverProc* catchall = new RuleBasedHostResolverProc(NULL);
-#if defined(OS_ANDROID)
-  // In Android emulator, the development machine's '127.0.0.1' is mapped to
-  // '10.0.2.2'.
-  catchall->AddIPLiteralRule("*", "10.0.2.2", "localhost");
-#else
-  catchall->AddIPLiteralRule("*", "127.0.0.1", "localhost");
-#endif
-
-  // Next add a rules-based layer the use controls.
-  return new RuleBasedHostResolverProc(catchall);
-}
-
 //-----------------------------------------------------------------------------
 
-int HangingHostResolver::Resolve(const RequestInfo& info,
-                                 AddressList* addresses,
-                                 OldCompletionCallback* callback,
-                                 RequestHandle* out_req,
-                                 const BoundNetLog& net_log) {
-  return ERR_IO_PENDING;
+WaitingHostResolverProc::WaitingHostResolverProc(HostResolverProc* previous)
+    : HostResolverProc(previous), event_(false, false) {}
+
+void WaitingHostResolverProc::Signal() {
+  event_.Signal();
 }
 
-int HangingHostResolver::ResolveFromCache(const RequestInfo& info,
-                                          AddressList* addresses,
-                                          const BoundNetLog& net_log) {
-  return ERR_DNS_CACHE_MISS;
+int WaitingHostResolverProc::Resolve(const std::string& host,
+                                     AddressFamily address_family,
+                                     HostResolverFlags host_resolver_flags,
+                                     AddressList* addrlist,
+                                     int* os_error) {
+  event_.Wait();
+  return ResolveUsingPrevious(host, address_family, host_resolver_flags,
+                              addrlist, os_error);
 }
 
+WaitingHostResolverProc::~WaitingHostResolverProc() {}
+
 //-----------------------------------------------------------------------------
 
 ScopedDefaultHostResolverProc::ScopedDefaultHostResolverProc() {}
diff --git a/net/base/mock_host_resolver.h b/net/base/mock_host_resolver.h
index 3c6f178..27360b0 100644
--- a/net/base/mock_host_resolver.h
+++ b/net/base/mock_host_resolver.h
@@ -7,28 +7,15 @@
 #pragma once
 
 #include <list>
-#include <map>
 
-#include "base/memory/weak_ptr.h"
-#include "base/observer_list.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/threading/non_thread_safe.h"
-#include "net/base/host_resolver.h"
+#include "net/base/host_resolver_impl.h"
 #include "net/base/host_resolver_proc.h"
 
 namespace net {
 
-class HostCache;
 class RuleBasedHostResolverProc;
 
-// Fills |*addrlist| with a socket address for |host_list| which should be a
-// comma-separated list of IPv4 or IPv6 literal(s) without enclosing brackets.
-// If |canonical_name| is non-empty it is used as the DNS canonical name for
-// the host. Returns OK on success, ERR_UNEXPECTED otherwise.
-int ParseAddressList(const std::string& host_list,
-                     const std::string& canonical_name,
-                     AddressList* addrlist);
-
 // In most cases, it is important that unit tests avoid relying on making actual
 // DNS queries since the resulting tests can be flaky, especially if the network
 // is unreliable for some reason.  To simplify writing tests that avoid making
@@ -50,9 +37,7 @@ int ParseAddressList(const std::string& host_list,
 // re-map one hostname to another as well.
 
 // Base class shared by MockHostResolver and MockCachingHostResolver.
-class MockHostResolverBase : public HostResolver,
-                             public base::SupportsWeakPtr<MockHostResolverBase>,
-                             public base::NonThreadSafe {
+class MockHostResolverBase : public HostResolver {
  public:
   virtual ~MockHostResolverBase();
 
@@ -66,6 +51,13 @@ class MockHostResolverBase : public HostResolver,
   // Resets the mock.
   void Reset(HostResolverProc* interceptor);
 
+  void SetPoolConstraints(HostResolverImpl::JobPoolIndex pool_index,
+                          size_t max_outstanding_jobs,
+                          size_t max_pending_requests) {
+    impl_->SetPoolConstraints(
+        pool_index, max_outstanding_jobs, max_pending_requests);
+  }
+
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
@@ -78,32 +70,16 @@ class MockHostResolverBase : public HostResolver,
   virtual void CancelRequest(RequestHandle req) OVERRIDE;
   virtual void AddObserver(Observer* observer) OVERRIDE;
   virtual void RemoveObserver(Observer* observer) OVERRIDE;
-  virtual HostCache* GetHostCache() OVERRIDE;
 
  protected:
-  explicit MockHostResolverBase(bool use_caching);
+  MockHostResolverBase(bool use_caching);
 
- private:
-  struct Request;
-  typedef std::map<size_t, Request*> RequestMap;
-
-  // Resolve as IP or from |cache_| return cached error or
-  // DNS_CACHE_MISS if failed.
-  int ResolveFromIPLiteralOrCache(const RequestInfo& info,
-                                  AddressList* addresses);
-  // Resolve via |proc_|.
-  int ResolveProc(size_t id, const RequestInfo& info, AddressList* addresses);
-  // Resolve request stored in |requests_|. Pass rv to callback.
-  void ResolveNow(size_t id);
-
-  bool synchronous_mode_;
-  ObserverList<Observer> observers_;
+  scoped_ptr<HostResolverImpl> impl_;
   scoped_refptr<RuleBasedHostResolverProc> rules_;
-  scoped_refptr<HostResolverProc> proc_;
-  scoped_ptr<HostCache> cache_;
-  RequestMap requests_;
-  size_t next_request_id_;
+  bool synchronous_mode_;
+  bool use_caching_;
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(MockHostResolverBase);
 };
 
@@ -178,23 +154,24 @@ class RuleBasedHostResolverProc : public HostResolverProc {
   RuleList rules_;
 };
 
-// Create rules that map all requests to localhost.
-RuleBasedHostResolverProc* CreateCatchAllHostResolverProc();
-
-// HangingHostResolver never completes its |Resolve| request.
-class HangingHostResolver : public HostResolver {
+// Using WaitingHostResolverProc you can simulate very long lookups.
+class WaitingHostResolverProc : public HostResolverProc {
  public:
-  virtual int Resolve(const RequestInfo& info,
-                      AddressList* addresses,
-                      OldCompletionCallback* callback,
-                      RequestHandle* out_req,
-                      const BoundNetLog& net_log) OVERRIDE;
-  virtual int ResolveFromCache(const RequestInfo& info,
-                               AddressList* addresses,
-                               const BoundNetLog& net_log) OVERRIDE;
-  virtual void CancelRequest(RequestHandle req) OVERRIDE {}
-  virtual void AddObserver(Observer* observer) OVERRIDE {}
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
+  explicit WaitingHostResolverProc(HostResolverProc* previous);
+
+  void Signal();
+
+  // HostResolverProc methods:
+  virtual int Resolve(const std::string& host,
+                      AddressFamily address_family,
+                      HostResolverFlags host_resolver_flags,
+                      AddressList* addrlist,
+                      int* os_error);
+
+ private:
+  virtual ~WaitingHostResolverProc();
+
+  base::WaitableEvent event_;
 };
 
 // This class sets the default HostResolverProc for a particular scope.  The
diff --git a/net/base/net_test_suite.cc b/net/base/net_test_suite.cc
index b3ee578..451a8aaa 100644
--- a/net/base/net_test_suite.cc
+++ b/net/base/net_test_suite.cc
@@ -5,7 +5,6 @@
 #include "net/base/net_test_suite.h"
 
 #include "base/message_loop.h"
-#include "net/base/network_change_notifier.h"
 #include "net/http/http_stream_factory.h"
 #if defined(USE_NSS)
 #include "net/ocsp/nss_ocsp.h"
diff --git a/net/base/single_request_host_resolver_unittest.cc b/net/base/single_request_host_resolver_unittest.cc
index ddf8c70e0..2fb781f 100644
--- a/net/base/single_request_host_resolver_unittest.cc
+++ b/net/base/single_request_host_resolver_unittest.cc
@@ -4,10 +4,8 @@
 
 #include "net/base/single_request_host_resolver.h"
 
-#include "net/base/address_list.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
-#include "net/base/net_log.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index 329c0cc..7d4329e 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -20,7 +20,6 @@
 #include "net/base/auth.h"
 #include "net/base/capturing_net_log.h"
 #include "net/base/completion_callback.h"
-#include "net/base/host_cache.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
@@ -9120,7 +9119,7 @@ class OneTimeCachingHostResolver : public net::HostResolver {
                                const BoundNetLog& net_log) OVERRIDE {
     int rv = host_resolver_.ResolveFromCache(info, addresses, net_log);
     if (rv == OK && info.host_port_pair().Equals(host_port_))
-      host_resolver_.GetHostCache()->clear();
+      host_resolver_.Reset(NULL);
     return rv;
   }
 
diff --git a/net/http/http_stream_factory_impl_unittest.cc b/net/http/http_stream_factory_impl_unittest.cc
index 818049f..dd08965 100644
--- a/net/http/http_stream_factory_impl_unittest.cc
+++ b/net/http/http_stream_factory_impl_unittest.cc
@@ -7,7 +7,6 @@
 #include <string>
 
 #include "base/basictypes.h"
-#include "net/base/capturing_net_log.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_log.h"
diff --git a/net/proxy/proxy_resolver_js_bindings_unittest.cc b/net/proxy/proxy_resolver_js_bindings_unittest.cc
index e4fa389..1c580b9 100644
--- a/net/proxy/proxy_resolver_js_bindings_unittest.cc
+++ b/net/proxy/proxy_resolver_js_bindings_unittest.cc
@@ -8,7 +8,6 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "net/base/address_list.h"
-#include "net/base/host_cache.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
@@ -34,14 +33,40 @@ class MockHostResolverWithMultipleResults : public SyncHostResolver {
   // HostResolver methods:
   virtual int Resolve(const HostResolver::RequestInfo& info,
                       AddressList* addresses) OVERRIDE {
-    return ParseAddressList("192.168.1.1,172.22.34.1,200.100.1.2", "",
-                            addresses);
+    // Build up the result list (in reverse).
+    AddressList temp_list = ResolveIPLiteral("200.100.1.2");
+    temp_list = PrependAddressToList("172.22.34.1", temp_list);
+    temp_list = PrependAddressToList("192.168.1.1", temp_list);
+    *addresses = temp_list;
+    return OK;
   }
 
   virtual void Shutdown() OVERRIDE {}
 
  private:
   virtual ~MockHostResolverWithMultipleResults() {}
+
+  // Resolves an IP literal to an address list.
+  AddressList ResolveIPLiteral(const char* ip_literal) {
+    AddressList result;
+    int rv = SystemHostResolverProc(ip_literal,
+                                    ADDRESS_FAMILY_UNSPECIFIED,
+                                    0,
+                                    &result, NULL);
+    EXPECT_EQ(OK, rv);
+    EXPECT_EQ(NULL, result.head()->ai_next);
+    return result;
+  }
+
+  // Builds an AddressList that is |ip_literal| + |orig_list|.
+  // |orig_list| must not be empty.
+  AddressList PrependAddressToList(const char* ip_literal,
+                                   const AddressList& orig_list) {
+    // Build an addrinfo for |ip_literal|.
+    AddressList result = ResolveIPLiteral(ip_literal);
+    result.Append(orig_list.head());
+    return result;
+  }
 };
 
 class MockFailingHostResolver : public SyncHostResolver {
diff --git a/net/socket/socket_test_util.cc b/net/socket/socket_test_util.cc
index 2444756..8191bbe 100644
--- a/net/socket/socket_test_util.cc
+++ b/net/socket/socket_test_util.cc
@@ -13,8 +13,8 @@
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "net/base/address_family.h"
-#include "net/base/address_list.h"
 #include "net/base/auth.h"
+#include "net/base/host_resolver_proc.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/ssl_info.h"
 #include "net/http/http_network_session.h"
@@ -656,19 +656,16 @@ bool MockClientSocket::IsConnectedAndIdle() const {
 }
 
 int MockClientSocket::GetPeerAddress(AddressList* address) const {
-  IPAddressNumber ip;
-  bool rv = ParseIPLiteralToNumber("192.0.2.33", &ip);
-  CHECK(rv);
-  *address = AddressList::CreateFromIPAddress(ip, 0);
-  return OK;
+  return net::SystemHostResolverProc("192.0.2.33", ADDRESS_FAMILY_UNSPECIFIED,
+                                     0, address, NULL);
 }
 
 int MockClientSocket::GetLocalAddress(IPEndPoint* address) const {
   IPAddressNumber ip;
-  bool rv = ParseIPLiteralToNumber("192.0.2.33", &ip);
-  CHECK(rv);
+  if (!ParseIPLiteralToNumber("192.0.2.33", &ip))
+    return ERR_FAILED;
   *address = IPEndPoint(ip, 123);
-  return OK;
+      return OK;
 }
 
 const BoundNetLog& MockClientSocket::NetLog() const {
@@ -680,7 +677,7 @@ void MockClientSocket::GetSSLInfo(net::SSLInfo* ssl_info) {
 }
 
 void MockClientSocket::GetSSLCertRequestInfo(
-  net::SSLCertRequestInfo* cert_request_info) {
+    net::SSLCertRequestInfo* cert_request_info) {
 }
 
 int MockClientSocket::ExportKeyingMaterial(const base::StringPiece& label,
diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc
index 0ed1834..ce80719 100644
--- a/net/socket/socks_client_socket_unittest.cc
+++ b/net/socket/socks_client_socket_unittest.cc
@@ -81,9 +81,9 @@ SOCKSClientSocket* SOCKSClientSocketTest::BuildMockSocket(
 // Implementation of HostResolver that never completes its resolve request.
 // We use this in the test "DisconnectWhileHostResolveInProgress" to make
 // sure that the outstanding resolve request gets cancelled.
-class HangingHostResolverWithCancel : public HostResolver {
+class HangingHostResolver : public HostResolver {
  public:
-  HangingHostResolverWithCancel() : outstanding_request_(NULL) {}
+  HangingHostResolver() : outstanding_request_(NULL) {}
 
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
@@ -121,7 +121,7 @@ class HangingHostResolverWithCancel : public HostResolver {
  private:
   RequestHandle outstanding_request_;
 
-  DISALLOW_COPY_AND_ASSIGN(HangingHostResolverWithCancel);
+  DISALLOW_COPY_AND_ASSIGN(HangingHostResolver);
 };
 
 // Tests a complete handshake and the disconnection.
@@ -371,8 +371,7 @@ TEST_F(SOCKSClientSocketTest, FailedDNS) {
 // Calls Disconnect() while a host resolve is in progress. The outstanding host
 // resolve should be cancelled.
 TEST_F(SOCKSClientSocketTest, DisconnectWhileHostResolveInProgress) {
-  scoped_ptr<HangingHostResolverWithCancel> hanging_resolver(
-    new HangingHostResolverWithCancel());
+  scoped_ptr<HangingHostResolver> hanging_resolver(new HangingHostResolver());
 
   // Doesn't matter what the socket data is, we will never use it -- garbage.
   MockWrite data_writes[] = { MockWrite(false, "", 0) };