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/net_log.h"
@@ skipping 20 matching lines @@
     EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen);
 
     const struct sockaddr* sa = ainfo->ai_addr;
     const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa;
     EXPECT_TRUE(htons(port) == sa_in->sin_port);
     EXPECT_STREQ(*i, NetAddressToString(sa, ainfo->ai_addrlen).c_str());
   }
   ASSERT_EQ(static_cast<addrinfo*>(NULL), ainfo);
 }
 
+HostCache* CreateDefaultCache() {
+  return new HostCache(
+      100,  // max cache entries.
+      base::TimeDelta::FromMinutes(1),
+      base::TimeDelta::FromSeconds(0));
+}
+
 }  // namespace
 
 static const int kPortNum = 80;
 static const size_t kMaxTransactions = 2;
 static const size_t kMaxPendingRequests = 1;
 static int transaction_ids[] = {0, 1, 2, 3};
 
 // The following fixture sets up an environment for four different lookups
 // with their data defined in dns_test_util.h.  All tests make use of these
 // predefined variables instead of each defining their own, to avoid
@@ skipping 13 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));
+            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_|,

[cbentzel, 2011/07/21 15:31:10]

Could you add tests for cache expiration as well? 

[agayev, 2011/07/21 17:48:03]

Like creating a cache with 10ms TTL and then sleep and then make sure it is
expired?  Doesn't that belong to HostCache unit test?

[cbentzel, 2011/07/21 18:22:15]

yeah, you're right. 

+  // 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