[net/dns] Serve requests from HOSTS file if possible.

net/base/host_resolver_impl_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/base/host_resolver_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 10 matching lines @@
 #include "base/time.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.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_unittest.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
+#include "net/dns/dns_client.h"
+#include "net/dns/dns_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
+namespace {
 
 using base::TimeDelta;
 using base::TimeTicks;
 
-static const size_t kMaxJobs = 10u;
-static const size_t kMaxRetryAttempts = 4u;
+const size_t kMaxJobs = 10u;
+const size_t kMaxRetryAttempts = 4u;
 
 PrioritizedDispatcher::Limits DefaultLimits() {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, kMaxJobs);
   return limits;
 }
 
 HostResolverImpl::ProcTaskParams DefaultParams(
     HostResolverProc* resolver_proc) {
   return HostResolverImpl::ProcTaskParams(resolver_proc,
                                           kMaxRetryAttempts);
 }
 
 HostResolverImpl* CreateHostResolverImpl(HostResolverProc* resolver_proc) {
   return new HostResolverImpl(
       HostCache::CreateDefaultCache(),
       DefaultLimits(),
       DefaultParams(resolver_proc),
       scoped_ptr<DnsConfigService>(NULL),
       NULL);
 }
 
+HostResolverImpl* CreateHostResolverImplWithDnsConfig(
+    HostResolverProc* resolver_proc,
+    scoped_ptr<DnsConfigService> config_service) {
+  return new HostResolverImpl(
+      HostCache::CreateDefaultCache(),
+      DefaultLimits(),
+      DefaultParams(resolver_proc),
+      config_service.Pass(),
+      NULL);
+}
+
 // This HostResolverImpl will only allow 1 outstanding resolve at a time.
 HostResolverImpl* CreateSerialHostResolverImpl(
     HostResolverProc* resolver_proc) {
   HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc);
   params.max_retry_attempts = 0u;
 
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
 
   return new HostResolverImpl(HostCache::CreateDefaultCache(),
                               limits,
@@ skipping 319 matching lines @@
 // resolve results by forwarding them to Delegate.
 class ResolveRequest {
  public:
   // Delegate interface, for notification when the ResolveRequest completes.
   class Delegate {
    public:
     virtual ~Delegate() {}
     virtual void OnCompleted(ResolveRequest* resolve) = 0;
   };
 
+  // For asynchronous resolutions.
   ResolveRequest(HostResolver* resolver,
                  const std::string& hostname,
                  int port,
                  Delegate* delegate)
       : info_(HostPortPair(hostname, port)),
         resolver_(resolver),
         delegate_(delegate)  {
     // Start the request.
     int err = resolver->Resolve(
         info_, &addrlist_,
         base::Bind(&ResolveRequest::OnLookupFinished, base::Unretained(this)),
         &req_, BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, err);
   }
 
+  // For asynchronous resolutions.
   ResolveRequest(HostResolver* resolver,
                  const HostResolver::RequestInfo& info,
                  Delegate* delegate)
       : info_(info), resolver_(resolver), delegate_(delegate) {
     // Start the request.
     int err = resolver->Resolve(
         info, &addrlist_,
         base::Bind(&ResolveRequest::OnLookupFinished,
                    base::Unretained(this)),
-       &req_, BoundNetLog());
+        &req_, BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, err);
   }
 
+  // For synchronous resolutions.
+  ResolveRequest(HostResolver* resolver,
+                 const std::string& hostname,
+                 int port)
+      : info_(HostPortPair(hostname, port)),
+        resolver_(resolver),
+        delegate_(NULL)  {
+    // Start the request.
+    result_ = resolver->Resolve(
+        info_, &addrlist_,
+        base::Bind(&ResolveRequest::OnLookupFinished, base::Unretained(this)),
+        &req_, BoundNetLog());
+    EXPECT_NE(ERR_IO_PENDING, result_);
+  }
+
+  // For synchronous resolutions.
+  ResolveRequest(HostResolver* resolver,
+                 const HostResolver::RequestInfo& info)
+      : info_(info),
+        resolver_(resolver),
+        delegate_(NULL)  {
+    // Start the request.
+    result_ = resolver->Resolve(
+        info_, &addrlist_,
+        base::Bind(&ResolveRequest::OnLookupFinished, base::Unretained(this)),
+        &req_, BoundNetLog());
+    EXPECT_NE(ERR_IO_PENDING, result_);
+  }
+
   void Cancel() {
     resolver_->CancelRequest(req_);
   }
 
   const std::string& hostname() const {
     return info_.hostname();
   }
 
   int port() const {
     return info_.port();
   }
 
   int result() const {
     return result_;
   }
 
   const AddressList& addrlist() const {
     return addrlist_;
   }
 
   HostResolver* resolver() const {
     return resolver_;
   }
 
  private:
   void OnLookupFinished(int result) {
+    EXPECT_TRUE(delegate_ != NULL);
+    if (delegate_ == NULL)
+      return;
     result_ = result;
     delegate_->OnCompleted(this);
   }
 
   // The request details.
   HostResolver::RequestInfo info_;
   HostResolver::RequestHandle req_;
 
   // The result of the resolve.
   int result_;
   AddressList addrlist_;
 
   HostResolver* resolver_;
 
   Delegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ResolveRequest);
 };
 
+// TODO(szym): Make this fixture more useful. http://crbug.com/117830
 class HostResolverImplTest : public testing::Test {
  public:
   HostResolverImplTest()
       : callback_called_(false),
         ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
             base::Bind(&HostResolverImplTest::OnLookupFinished,
                        base::Unretained(this)))) {
   }
 
  protected:
   void OnLookupFinished(int result) {
     callback_called_ = true;
     callback_result_ = result;
     MessageLoop::current()->Quit();
   }
 
   bool callback_called_;
   int callback_result_;
   CompletionCallback callback_;
 };
 
+// Returns the first address in |addr_list| in "host:port" form, empty string if
+// the list is empty, or "UNSUPPORTED" if the address cannot be converted.
+std::string FirstAddressToString(const AddressList& addr_list) {
+  const struct addrinfo* ai = addr_list.head();
+  if (!ai)
+    return "";
+  std::string out = NetAddressToStringWithPort(ai);
+  if (out.empty())
+    return "UNSUPPORTED";
+  return out;
+}
+
+// Returns the number of addresses in |addr_list|.
+unsigned NumberOfAddresses(const AddressList& addr_list) {
+  unsigned count = 0;
+  for (const struct addrinfo* ai = addr_list.head();
+       ai != NULL;
+       ai = ai->ai_next) {
+    ++count;
+  }
+  return count;
+}
+
+}  // namespace net
+
 TEST_F(HostResolverImplTest, AsynchronousLookup) {
   AddressList addrlist;
-  const int kPortnum = 80;
 
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
       new RuleBasedHostResolverProc(NULL));
   resolver_proc->AddRule("just.testing", "192.168.1.42");
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
 
-  HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
+  HostResolver::RequestInfo info(HostPortPair("just.testing", 80));
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   int err = host_resolver->Resolve(info, &addrlist, callback_, NULL,
                                    log.bound());
   EXPECT_EQ(ERR_IO_PENDING, err);
 
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(1u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
 
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(callback_called_);
   ASSERT_EQ(OK, callback_result_);
 
   log.GetEntries(&entries);
 
   EXPECT_EQ(2u, entries.size());
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
 
-  const struct addrinfo* ainfo = addrlist.head();
-  EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
-  EXPECT_EQ(sizeof(struct sockaddr_in), static_cast<size_t>(ainfo->ai_addrlen));
-
-  const struct sockaddr* sa = ainfo->ai_addr;
-  const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa;
-  EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port);
-  EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr);
+  EXPECT_EQ("192.168.1.42:80", FirstAddressToString(addrlist));
+  EXPECT_EQ(1u, NumberOfAddresses(addrlist));
 }
 
 TEST_F(HostResolverImplTest, FailedAsynchronousLookup) {
   AddressList addrlist;
-  const int kPortnum = 80;
-
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
       new RuleBasedHostResolverProc(NULL));
   resolver_proc->AddSimulatedFailure("just.testing");
 
   scoped_ptr<HostResolver> host_resolver(CreateHostResolverImpl(resolver_proc));
 
-  HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
+  HostResolver::RequestInfo info(HostPortPair("just.testing", 80));
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   int err = host_resolver->Resolve(info, &addrlist, callback_, NULL,
                                    log.bound());
   EXPECT_EQ(ERR_IO_PENDING, err);
 
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(1u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
@@ skipping 23 matching lines @@
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   {
     // This resolver will be destroyed while a lookup is running on WorkerPool.
     scoped_ptr<HostResolver> host_resolver(
         new HostResolverImpl(HostCache::CreateDefaultCache(),
                              DefaultLimits(),
                              DefaultParams(resolver_proc),
                              scoped_ptr<DnsConfigService>(NULL),
                              &net_log));
     AddressList addrlist;
-    const int kPortnum = 80;
-
-    HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
+    HostResolver::RequestInfo info(HostPortPair("just.testing", 80));
     int err = host_resolver->Resolve(info, &addrlist, callback_, NULL,
                                      log.bound());
     EXPECT_EQ(ERR_IO_PENDING, err);
 
     resolver_proc->Wait();
   }
 
   resolver_proc->Signal();
 
   CapturingNetLog::EntryList entries;
@@ skipping 39 matching lines @@
 TEST_F(HostResolverImplTest, NumericIPv4Address) {
   // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.
 
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
       new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
-  const int kPortnum = 5555;
   TestCompletionCallback callback;
-  HostResolver::RequestInfo info(HostPortPair("127.1.2.3", kPortnum));
+  HostResolver::RequestInfo info(HostPortPair("127.1.2.3", 5555));
   int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(OK, err);
 
-  const struct addrinfo* ainfo = addrlist.head();
-  EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
-  EXPECT_EQ(sizeof(struct sockaddr_in), static_cast<size_t>(ainfo->ai_addrlen));
-
-  const struct sockaddr* sa = ainfo->ai_addr;
-  const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa;
-  EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port);
-  EXPECT_TRUE(htonl(0x7f010203) == sa_in->sin_addr.s_addr);
+  EXPECT_EQ("127.1.2.3:5555", FirstAddressToString(addrlist));
+  EXPECT_EQ(1u, NumberOfAddresses(addrlist));
 }
 
 TEST_F(HostResolverImplTest, NumericIPv6Address) {
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
       new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   // Resolve a plain IPv6 address.  Don't worry about [brackets], because
   // the caller should have removed them.
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
-  const int kPortnum = 5555;
   TestCompletionCallback callback;
-  HostResolver::RequestInfo info(HostPortPair("2001:db8::1", kPortnum));
+  HostResolver::RequestInfo info(HostPortPair("2001:db8::1", 5555));
   int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(OK, err);
 
-  const struct addrinfo* ainfo = addrlist.head();
-  EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
-  EXPECT_EQ(sizeof(struct sockaddr_in6),
-            static_cast<size_t>(ainfo->ai_addrlen));
-
-  const struct sockaddr* sa = ainfo->ai_addr;
-  const struct sockaddr_in6* sa_in6 = (const struct sockaddr_in6*) sa;
-  EXPECT_TRUE(htons(kPortnum) == sa_in6->sin6_port);
-
-  const uint8 expect_addr[] = {
-    0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
-  };
-  for (int i = 0; i < 16; i++) {
-    EXPECT_EQ(expect_addr[i], sa_in6->sin6_addr.s6_addr[i]);
-  }
+  std::string ipv6string = FirstAddressToString(addrlist);
+  if (ipv6string != "UNSUPPORTED")
+    EXPECT_EQ("[2001:db8::1]:5555", ipv6string);
+  EXPECT_EQ(1u, NumberOfAddresses(addrlist));
 }
 
 TEST_F(HostResolverImplTest, EmptyHost) {
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
       new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
-  const int kPortnum = 5555;
   TestCompletionCallback callback;
-  HostResolver::RequestInfo info(HostPortPair("", kPortnum));
+  HostResolver::RequestInfo info(HostPortPair("", 5555));
   int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, err);
 }
 
 TEST_F(HostResolverImplTest, LongHost) {
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
       new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
-  const int kPortnum = 5555;
   std::string hostname(4097, 'a');
   TestCompletionCallback callback;
-  HostResolver::RequestInfo info(HostPortPair(hostname, kPortnum));
+  HostResolver::RequestInfo info(HostPortPair(hostname, 5555));
   int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, err);
 }
 
 // Helper class used by HostResolverImplTest.DeDupeRequests. It receives request
 // completion notifications for all the resolves, so it can tally up and
 // determine when we are done.
 class DeDupeRequestsVerifier : public ResolveRequest::Delegate {
  public:
@@ skipping 118 matching lines @@
   req3.Cancel();
   req5.Cancel();
 
   // Ready, Set, GO!!!
   resolver_proc->Signal();
 
   // |verifier| will send quit message once all the requests have finished.
   MessageLoop::current()->Run();
 }
 
-// Helper class used by HostResolverImplTest.CanceledRequestsReleaseJobSlots.
+// Delegate which allows to wait for specific number of requests to complete.
+// Used by HostResolverImplTest.CanceledRequestsReleaseJobSlots and .DnsTask.
 class CountingDelegate : public ResolveRequest::Delegate {
  public:
-  CountingDelegate() : num_completions_(0) {}
+  CountingDelegate() : num_completions_(0), awaited_num_completions_(0) {}
 
   virtual void OnCompleted(ResolveRequest* resolve) OVERRIDE {
     ++num_completions_;
-    MessageLoop::current()->Quit();
+    if (num_completions_ == awaited_num_completions_)
+      MessageLoop::current()->Quit();
   }
 
   unsigned num_completions() const { return num_completions_; }
 
+  void WaitForCompletions(unsigned completions) {
+    ASSERT_LT(num_completions_, completions);
+    awaited_num_completions_ = completions;
+    MessageLoop::current()->Run();
+    EXPECT_EQ(completions, num_completions_);
+  }
+
  private:
   unsigned num_completions_;
+  unsigned awaited_num_completions_;
 };
 
 TEST_F(HostResolverImplTest, CanceledRequestsReleaseJobSlots) {
   scoped_refptr<CountingHostResolverProc> resolver_proc(
       new CountingHostResolverProc(NULL));
 
   scoped_ptr<HostResolverImpl> host_resolver(
       CreateHostResolverImpl(resolver_proc));
 
   CountingDelegate delegate;
@@ skipping 14 matching lines @@
   // Cancel all but last two.
   for (unsigned i = 0; i < requests.size() - 2; ++i) {
     requests[i]->Cancel();
   }
 
   EXPECT_TRUE(resolver_proc->WaitFor(kMaxJobs + 1));
   EXPECT_EQ(0u, delegate.num_completions());
 
   resolver_proc->SignalAll();
 
-  while (delegate.num_completions() < 2)
-    MessageLoop::current()->Run();
+  delegate.WaitForCompletions(2);
 
   EXPECT_EQ(0u, host_resolver->num_running_jobs_for_tests());
 }
 
 // Helper class used by HostResolverImplTest.CancelWithinCallback.
 class CancelWithinCallbackVerifier : public ResolveRequest::Delegate {
  public:
   CancelWithinCallbackVerifier()
       : req_to_cancel1_(NULL), req_to_cancel2_(NULL), num_completions_(0) {
   }
@@ skipping 654 matching lines @@
   EXPECT_EQ(ADDRESS_FAMILY_IPV4, capture_list[0].address_family);
 
   EXPECT_EQ("h1", capture_list[1].hostname);
   EXPECT_EQ(ADDRESS_FAMILY_IPV6, capture_list[1].address_family);
 
   // Now check that the correct resolved IP addresses were returned.
   // Addresses take the form: 192.x.y.z
   //    x = length of hostname
   //    y = ASCII value of hostname[0]
   //    z = value of address family
-  EXPECT_EQ("192.2.104.1", NetAddressToString(addrlist[0].head()));
-  EXPECT_EQ("192.2.104.1", NetAddressToString(addrlist[1].head()));
-  EXPECT_EQ("192.2.104.2", NetAddressToString(addrlist[2].head()));
+  EXPECT_EQ("192.2.104.1:80", FirstAddressToString(addrlist[0]));
+  EXPECT_EQ("192.2.104.1:80", FirstAddressToString(addrlist[1]));
+  EXPECT_EQ("192.2.104.2:80", FirstAddressToString(addrlist[2]));
+  EXPECT_EQ(1u, NumberOfAddresses(addrlist[0]));
+  EXPECT_EQ(1u, NumberOfAddresses(addrlist[1]));
+  EXPECT_EQ(1u, NumberOfAddresses(addrlist[2]));
 }
 
 // This is the exact same test as SetDefaultAddressFamily_IPv4, except the order
 // of requests 0 and 1 is flipped, and the default is set to IPv6 in place of
 // IPv4.
 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) {
   scoped_refptr<CapturingHostResolverProc> resolver_proc(
       new CapturingHostResolverProc(new EchoingHostResolverProc));
 
   scoped_ptr<HostResolverImpl> host_resolver(
@@ skipping 44 matching lines @@
   EXPECT_EQ(ADDRESS_FAMILY_IPV6, capture_list[0].address_family);
 
   EXPECT_EQ("h1", capture_list[1].hostname);
   EXPECT_EQ(ADDRESS_FAMILY_IPV4, capture_list[1].address_family);
 
   // Now check that the correct resolved IP addresses were returned.
   // Addresses take the form: 192.x.y.z
   //    x = length of hostname
   //    y = ASCII value of hostname[0]
   //    z = value of address family
-  EXPECT_EQ("192.2.104.2", NetAddressToString(addrlist[0].head()));
-  EXPECT_EQ("192.2.104.2", NetAddressToString(addrlist[1].head()));
-  EXPECT_EQ("192.2.104.1", NetAddressToString(addrlist[2].head()));
+  EXPECT_EQ("192.2.104.2:80", FirstAddressToString(addrlist[0]));
+  EXPECT_EQ("192.2.104.2:80", FirstAddressToString(addrlist[1]));
+  EXPECT_EQ("192.2.104.1:80", FirstAddressToString(addrlist[2]));
+  EXPECT_EQ(1u, NumberOfAddresses(addrlist[0]));
+  EXPECT_EQ(1u, NumberOfAddresses(addrlist[1]));
+  EXPECT_EQ(1u, NumberOfAddresses(addrlist[2]));
 }
 
 TEST_F(HostResolverImplTest, DisallowNonCachedResponses) {
   AddressList addrlist;
-  const int kPortnum = 80;
 
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
       new RuleBasedHostResolverProc(NULL));
   resolver_proc->AddRule("just.testing", "192.168.1.42");
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
 
   // First hit will miss the cache.
-  HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
+  HostResolver::RequestInfo info(HostPortPair("just.testing", 80));
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   int err = host_resolver->ResolveFromCache(info, &addrlist, log.bound());
   EXPECT_EQ(ERR_DNS_CACHE_MISS, err);
 
   // This time, we fetch normally.
   TestCompletionCallback callback;
   err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                log.bound());
   EXPECT_EQ(ERR_IO_PENDING, err);
   err = callback.WaitForResult();
   EXPECT_EQ(OK, err);
 
   // Now we should be able to fetch from the cache.
   err = host_resolver->ResolveFromCache(info, &addrlist, log.bound());
   EXPECT_EQ(OK, err);
 
-  const struct addrinfo* ainfo = addrlist.head();
-  EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
-  EXPECT_EQ(sizeof(struct sockaddr_in), static_cast<size_t>(ainfo->ai_addrlen));
-
-  const struct sockaddr* sa = ainfo->ai_addr;
-  const struct sockaddr_in* sa_in = reinterpret_cast<const sockaddr_in*>(sa);
-  EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port);
-  EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr);
+  EXPECT_EQ("192.168.1.42:80", FirstAddressToString(addrlist));
+  EXPECT_EQ(1u, NumberOfAddresses(addrlist));
 }
 
 // Test the retry attempts simulating host resolver proc that takes too long.
 TEST_F(HostResolverImplTest, MultipleAttempts) {
   // Total number of attempts would be 3 and we want the 3rd attempt to resolve
   // the host. First and second attempt will be forced to sleep until they get
   // word that a resolution has completed. The 3rd resolution attempt will try
   // to get done ASAP, and won't sleep..
   int kAttemptNumberToResolve = 3;
   int kTotalAttempts = 3;
@@ skipping 27 matching lines @@
   // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
   EXPECT_EQ(-4, callback.WaitForResult());
 
   resolver_proc->WaitForAllAttemptsToFinish(TimeDelta::FromMilliseconds(60000));
   MessageLoop::current()->RunAllPending();
 
   EXPECT_EQ(resolver_proc->total_attempts_resolved(), kTotalAttempts);
   EXPECT_EQ(resolver_proc->resolved_attempt_number(), kAttemptNumberToResolve);
 }
 
+DnsConfig CreateValidDnsConfig() {
+  IPAddressNumber dns_ip;
+  bool rv = ParseIPLiteralToNumber("192.168.1.0", &dns_ip);
+  EXPECT_TRUE(rv);
+
+  DnsConfig config;
+  config.nameservers.push_back(IPEndPoint(dns_ip,
+                                          dns_protocol::kDefaultPort));
+  EXPECT_TRUE(config.IsValid());
+  return config;
+}
+
+// TODO(szym): Test AbortAllInProgressJobs due to DnsConfig change.
+
 // TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
 
+// Test successful and fallback resolutions in HostResolverImpl::DnsTask.
+TEST_F(HostResolverImplTest, DnsTask) {
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
+  scoped_ptr<HostResolverImpl> host_resolver(CreateHostResolverImpl(
+      resolver_proc));
+
+  resolver_proc->AddRule("er_succeed", "192.168.1.101");
+  resolver_proc->AddRule("nx_succeed", "192.168.1.102");
+  resolver_proc->AddSimulatedFailure("ok_fail");
+  resolver_proc->AddSimulatedFailure("er_fail");
+  resolver_proc->AddSimulatedFailure("nx_fail");
+
+  CountingDelegate delegate;
+
+  // Initially there is no config, so client should not be invoked.
+  ResolveRequest req1(host_resolver.get(), "ok_fail", 80, &delegate);
+
+  delegate.WaitForCompletions(1);
+  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req1.result());
+
+  host_resolver->set_dns_client_for_tests(
+      CreateMockDnsClient(CreateValidDnsConfig()));
+
+  ResolveRequest req2(host_resolver.get(), "ok_fail", 80, &delegate);
+  ResolveRequest req3(host_resolver.get(), "er_fail", 80, &delegate);
+  ResolveRequest req4(host_resolver.get(), "nx_fail", 80, &delegate);
+  ResolveRequest req5(host_resolver.get(), "er_succeed", 80, &delegate);
+  ResolveRequest req6(host_resolver.get(), "nx_succeed", 80, &delegate);
+
+  delegate.WaitForCompletions(6);
+  EXPECT_EQ(OK, req2.result());
+  // Resolved by MockDnsClient.
+  EXPECT_EQ("127.0.0.1:80", FirstAddressToString(req2.addrlist()));
+  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req3.result());
+  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req4.result());
+  EXPECT_EQ(OK, req5.result());
+  EXPECT_EQ("192.168.1.101:80", FirstAddressToString(req5.addrlist()));
+  EXPECT_EQ(OK, req6.result());
+  EXPECT_EQ("192.168.1.102:80", FirstAddressToString(req6.addrlist()));
+}
+
+TEST_F(HostResolverImplTest, ServeFromHosts) {
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
+  MockDnsConfigService* config_service = new MockDnsConfigService();
+  scoped_ptr<HostResolverImpl> host_resolver(
+      CreateHostResolverImplWithDnsConfig(
+          resolver_proc,
+          scoped_ptr<DnsConfigService>(config_service)));
+
+  resolver_proc->AddSimulatedFailure("*");
+
+  DnsConfig config = CreateValidDnsConfig();
+  host_resolver->set_dns_client_for_tests(CreateMockDnsClient(config));
+
+  CountingDelegate delegate;
+
+  ResolveRequest req1(host_resolver.get(), "er_ipv4", 80, &delegate);
+  delegate.WaitForCompletions(1);
+  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req1.result());
+
+  IPAddressNumber local_ipv4, local_ipv6;
+  ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4));
+  ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6));
+
+  DnsHosts hosts;
+  hosts[DnsHostsKey("er_ipv4", ADDRESS_FAMILY_IPV4)] = local_ipv4;
+  hosts[DnsHostsKey("er_ipv6", ADDRESS_FAMILY_IPV6)] = local_ipv6;
+  hosts[DnsHostsKey("er_both", ADDRESS_FAMILY_IPV4)] = local_ipv4;
+  hosts[DnsHostsKey("er_both", ADDRESS_FAMILY_IPV6)] = local_ipv6;
+
+  config_service->ChangeConfig(config);
+  config_service->ChangeHosts(hosts);
+
+  ResolveRequest req2(host_resolver.get(), "er_ipv4", 80);
+  EXPECT_EQ(OK, req2.result());
+  EXPECT_EQ("127.0.0.1:80", FirstAddressToString(req2.addrlist()));
+
+  ResolveRequest req3(host_resolver.get(), "er_ipv6", 80);
+  EXPECT_EQ(OK, req3.result());
+  std::string ipv6string = FirstAddressToString(req3.addrlist());
+  if (ipv6string != "UNSUPPORTED")
+    EXPECT_EQ("[::1]:80", ipv6string);
+
+  ResolveRequest req4(host_resolver.get(), "er_both", 80);
+  EXPECT_EQ(OK, req4.result());
+  // Either result is satisfactory. http://crbug.com/117850
+  const addrinfo* addr = req4.addrlist().head();
+  if (addr->ai_addrlen == sizeof(struct sockaddr_in)) {
+    EXPECT_EQ("127.0.0.1", NetAddressToString(addr));
+  } else {
+    ipv6string = NetAddressToString(addr);
+    if (ipv6string != "UNSUPPORTED")
+      EXPECT_EQ("::1", NetAddressToString(addr));
+  }
+  EXPECT_GE(NumberOfAddresses(req4.addrlist()), 1u);
+
+  // Requests with specified AddressFamily.
+  HostResolver::RequestInfo info(HostPortPair("er_both", 80));
+  info.set_address_family(ADDRESS_FAMILY_IPV4);
+  ResolveRequest req5(host_resolver.get(), info);
+  EXPECT_EQ(OK, req5.result());
+  EXPECT_EQ("127.0.0.1:80", FirstAddressToString(req5.addrlist()));
+  EXPECT_EQ(1u, NumberOfAddresses(req5.addrlist()));
+
+  info.set_address_family(ADDRESS_FAMILY_IPV6);
+  ResolveRequest req6(host_resolver.get(), info);
+  EXPECT_EQ(OK, req6.result());
+  ipv6string = FirstAddressToString(req6.addrlist());
+  if (ipv6string != "UNSUPPORTED")
+    EXPECT_EQ("[::1]:80", ipv6string);
+  EXPECT_EQ(1u, NumberOfAddresses(req6.addrlist()));
+}
+
 }  // namespace net