AsyncHostResolver: integrated HostCache, temporarily, until we have RR cache.

net/base/async_host_resolver_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 "net/base/async_host_resolver.h"
 
 #include "base/bind.h"
 #include "base/scoped_ptr.h"
 #include "net/base/dns_test_util.h"
+#include "net/base/host_cache.h"
 #include "net/base/net_log.h"
 #include "net/base/rand_callback.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/socket/socket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
@@ skipping 44 matching lines @@
         ip_addresses0_(kT0IpAddresses,
             kT0IpAddresses + arraysize(kT0IpAddresses)),
         ip_addresses1_(kT1IpAddresses,
             kT1IpAddresses + arraysize(kT1IpAddresses)),
         ip_addresses2_(kT2IpAddresses,
             kT2IpAddresses + arraysize(kT2IpAddresses)),
         ip_addresses3_(kT3IpAddresses,
             kT3IpAddresses + arraysize(kT3IpAddresses)),
         test_prng_(std::deque<int>(
             transaction_ids, transaction_ids + arraysize(transaction_ids))) {
-
     rand_int_cb_ = base::Bind(&TestPrng::GetNext,
                               base::Unretained(&test_prng_));
     // AF_INET only for now.
     info0_.set_address_family(ADDRESS_FAMILY_IPV4);
     info1_.set_address_family(ADDRESS_FAMILY_IPV4);
     info2_.set_address_family(ADDRESS_FAMILY_IPV4);
     info3_.set_address_family(ADDRESS_FAMILY_IPV4);
 
     // Setup socket read/writes for transaction 0.
     writes0_.push_back(
@@ skipping 40 matching lines @@
     factory_.AddSocketDataProvider(data2_.get());
     factory_.AddSocketDataProvider(data3_.get());
 
     IPEndPoint dns_server;
     bool rv0 = CreateDnsAddress(kDnsIp, kDnsPort, &dns_server);
     DCHECK(rv0);
 
     resolver_.reset(
         new AsyncHostResolver(
             dns_server, kMaxTransactions, kMaxPendingRequests, rand_int_cb_,
-            &factory_, NULL));
+            HostCache::CreateDefaultCache(), &factory_, NULL));
   }
 
  protected:
   AddressList addrlist0_, addrlist1_, addrlist2_, addrlist3_;
   HostResolver::RequestInfo info0_, info1_, info2_, info3_;
   std::vector<MockWrite> writes0_, writes1_, writes2_, writes3_;
   std::vector<MockRead> reads0_, reads1_, reads2_, reads3_;
   scoped_ptr<StaticSocketDataProvider> data0_, data1_, data2_, data3_;
   std::vector<const char*> ip_addresses0_, ip_addresses1_,
     ip_addresses2_, ip_addresses3_;
@@ skipping 24 matching lines @@
 }
 
 TEST_F(AsyncHostResolverTest, IPv6LiteralLookup) {
   info0_.set_host_port_pair(HostPortPair("2001:db8:0::42", kPortNum));
   int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
                               BoundNetLog());
   // When support for IPv6 is added, this should succeed.
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
-TEST_F(AsyncHostResolverTest, CachedOnlyLookup) {
+TEST_F(AsyncHostResolverTest, CachedLookup) {
   info0_.set_only_use_cached_response(true);
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, NULL, NULL,
                               BoundNetLog());
-  // When caching is added, this should succeed.
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
+
+  // Cache the result of |info0_| lookup.
+  info0_.set_only_use_cached_response(false);
+  rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+                          BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  rv = callback0_.WaitForResult();
+  EXPECT_EQ(OK, rv);
+  VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_);
+
+  // Now lookup |info0_| from cache only, store results in |addrlist1_|,
+  // should succeed synchronously.
+  info0_.set_only_use_cached_response(true);
+  rv = resolver_->Resolve(info0_, &addrlist1_, NULL, NULL,
+                              BoundNetLog());
+  EXPECT_EQ(OK, rv);
+  VerifyAddressList(ip_addresses0_, kPortNum, addrlist1_);
 }
 
 TEST_F(AsyncHostResolverTest, InvalidHostNameLookup) {
   const std::string kHostName1(64, 'a');
   info0_.set_host_port_pair(HostPortPair(kHostName1, kPortNum));
   int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 
   const std::string kHostName2(4097, 'b');
@@ skipping 369 matching lines @@
 
   EXPECT_EQ(4u, observer.start_log.size()); // Was incremented by 1.
   EXPECT_EQ(2u, observer.finish_log.size());
   EXPECT_EQ(1u, observer.cancel_log.size());
 
   EXPECT_TRUE(observer.start_log[3] ==
               TestHostResolverObserver::StartOrCancelEntry(4, info3_));
 }
 
 }  // namespace net