Cache failed DNS resolutions for 1 second....

net/base/host_resolver_impl_unittest.cc

 // Copyright (c) 2006-2008 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"
 
 #if defined(OS_WIN)
 #include <ws2tcpip.h>
 #include <wspiapi.h>
 #elif defined(OS_POSIX)
@@ skipping 12 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // TODO(eroman):
 //  - Test mixing async with sync (in particular how does sync update the
 //    cache while an async is already pending).
 
 namespace net {
 namespace {
-const int kMaxCacheEntries = 100;
-const int kMaxCacheAgeMs = 60000;
+
+HostCache* CreateDefaultCache() {
+  return new HostCache(
+      100,  // max cache entries.
+      base::TimeDelta::FromMinutes(1),
+      base::TimeDelta::FromSeconds(0));
+}
 
 // A variant of WaitingHostResolverProc that pushes each host mapped into a
 // list.
 // (and uses a manual-reset event rather than auto-reset).
 class CapturingHostResolverProc : public HostResolverProc {
  public:
   explicit CapturingHostResolverProc(HostResolverProc* previous)
       : HostResolverProc(previous), event_(true, false) {
   }
 
@@ skipping 134 matching lines @@
 
 TEST_F(HostResolverImplTest, SynchronousLookup) {
   AddressList adrlist;
   const int kPortnum = 80;
 
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
       new RuleBasedHostResolverProc(NULL);
   resolver_proc->AddRule("just.testing", "192.168.1.42");
 
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache()));
 
   HostResolver::RequestInfo info("just.testing", kPortnum);
   scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
   int err = host_resolver->Resolve(info, &adrlist, NULL, NULL, log);
   EXPECT_EQ(OK, err);
 
   EXPECT_EQ(2u, log->events().size());
   ExpectLogContains(log, 0, LoadLog::TYPE_HOST_RESOLVER_IMPL,
                     LoadLog::PHASE_BEGIN);
   ExpectLogContains(log, 1, LoadLog::TYPE_HOST_RESOLVER_IMPL,
@@ skipping 11 matching lines @@
 
 TEST_F(HostResolverImplTest, AsynchronousLookup) {
   AddressList adrlist;
   const int kPortnum = 80;
 
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
       new RuleBasedHostResolverProc(NULL);
   resolver_proc->AddRule("just.testing", "192.168.1.42");
 
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache()));
 
   HostResolver::RequestInfo info("just.testing", kPortnum);
   scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
   int err = host_resolver->Resolve(info, &adrlist, &callback_, NULL, log);
   EXPECT_EQ(ERR_IO_PENDING, err);
 
   EXPECT_EQ(1u, log->events().size());
   ExpectLogContains(log, 0, LoadLog::TYPE_HOST_RESOLVER_IMPL,
                     LoadLog::PHASE_BEGIN);
 
@@ skipping 16 matching lines @@
   EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr);
 }
 
 TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) {
   scoped_refptr<WaitingHostResolverProc> resolver_proc =
       new WaitingHostResolverProc(NULL);
 
   scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
   {
     scoped_refptr<HostResolver> host_resolver(
-        new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
+        new HostResolverImpl(resolver_proc, CreateDefaultCache()));
     AddressList adrlist;
     const int kPortnum = 80;
 
     HostResolver::RequestInfo info("just.testing", kPortnum);
     int err = host_resolver->Resolve(info, &adrlist, &callback_, NULL, log);
     EXPECT_EQ(ERR_IO_PENDING, err);
 
     // Make sure we will exit the queue even when callback is not called.
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                             new MessageLoop::QuitTask(),
@@ skipping 14 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_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache()));
   AddressList adrlist;
   const int kPortnum = 5555;
   HostResolver::RequestInfo info("127.1.2.3", kPortnum);
   int err = host_resolver->Resolve(info, &adrlist, NULL, NULL, NULL);
   EXPECT_EQ(OK, err);
 
   const struct addrinfo* ainfo = adrlist.head();
   EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
   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(kPortnum) == sa_in->sin_port);
   EXPECT_TRUE(htonl(0x7f010203) == sa_in->sin_addr.s_addr);
 }
 
 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_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache()));
   AddressList adrlist;
   const int kPortnum = 5555;
   HostResolver::RequestInfo info("2001:db8::1", kPortnum);
   int err = host_resolver->Resolve(info, &adrlist, NULL, NULL, NULL);
   // On computers without IPv6 support, getaddrinfo cannot convert IPv6
   // address literals to addresses (getaddrinfo returns EAI_NONAME).  So this
   // test has to allow host_resolver->Resolve to fail.
   if (err == ERR_NAME_NOT_RESOLVED)
     return;
   EXPECT_EQ(OK, err);
@@ skipping 14 matching lines @@
     EXPECT_EQ(expect_addr[i], sa_in6->sin6_addr.s6_addr[i]);
   }
 }
 
 TEST_F(HostResolverImplTest, EmptyHost) {
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
       new RuleBasedHostResolverProc(NULL);
   resolver_proc->AllowDirectLookup("*");
 
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache()));
   AddressList adrlist;
   const int kPortnum = 5555;
   HostResolver::RequestInfo info("", kPortnum);
   int err = host_resolver->Resolve(info, &adrlist, NULL, NULL, NULL);
   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.
@@ skipping 40 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DeDupeRequestsVerifier);
 };
 
 TEST_F(HostResolverImplTest, DeDupeRequests) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolve().  Also, the capturing resolver_proc is initially blocked.
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(NULL);
 
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache()));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
   DeDupeRequestsVerifier verifier(resolver_proc.get());
 
   // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
 
   ResolveRequest req1(host_resolver, "a", 80, &verifier);
   ResolveRequest req2(host_resolver, "b", 80, &verifier);
@@ skipping 30 matching lines @@
 };
 
 TEST_F(HostResolverImplTest, CancelMultipleRequests) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolver().  Also, the capturing resolver_proc is initially
   // blocked.
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(NULL);
 
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache()));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
   CancelMultipleRequestsVerifier verifier;
 
   // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
 
   ResolveRequest req1(host_resolver, "a", 80, &verifier);
   ResolveRequest req2(host_resolver, "b", 80, &verifier);
@@ skipping 66 matching lines @@
 };
 
 TEST_F(HostResolverImplTest, CancelWithinCallback) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolver().  Also, the capturing resolver_proc is initially
   // blocked.
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(NULL);
 
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache()));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
   CancelWithinCallbackVerifier verifier;
 
   // Start 4 requests, duplicating hosts "a". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
 
   ResolveRequest req1(host_resolver, "a", 80, &verifier);
   ResolveRequest req2(host_resolver, "a", 81, &verifier);
@@ skipping 40 matching lines @@
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolver().  Also, the capturing resolver_proc is initially
   // blocked.
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(NULL);
 
   // 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 =
-      new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs);
+      new HostResolverImpl(resolver_proc, CreateDefaultCache());
   DeleteWithinCallbackVerifier verifier(host_resolver);
 
   // Start 4 requests, duplicating hosts "a". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
 
   ResolveRequest req1(host_resolver, "a", 80, &verifier);
   ResolveRequest req2(host_resolver, "a", 81, &verifier);
   ResolveRequest req3(host_resolver, "a", 82, &verifier);
   ResolveRequest req4(host_resolver, "a", 83, &verifier);
 
@@ skipping 32 matching lines @@
 
 TEST_F(HostResolverImplTest, StartWithinCallback) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolver().  Also, the capturing resolver_proc is initially
   // blocked.
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(NULL);
 
   // Turn off caching for this host resolver.
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, 0, 0));
+      new HostResolverImpl(resolver_proc, NULL));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
   StartWithinCallbackVerifier verifier;
 
   // Start 4 requests, duplicating hosts "a". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
 
   ResolveRequest req1(host_resolver, "a", 80, &verifier);
   ResolveRequest req2(host_resolver, "a", 81, &verifier);
@@ skipping 44 matching lines @@
     }
   }
 
  private:
   scoped_ptr<ResolveRequest> final_request_;
   DISALLOW_COPY_AND_ASSIGN(BypassCacheVerifier);
 };
 
 TEST_F(HostResolverImplTest, BypassCache) {
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(NULL, kMaxCacheEntries, kMaxCacheAgeMs));
+      new HostResolverImpl(NULL, CreateDefaultCache()));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
   BypassCacheVerifier verifier;
 
   // Start a request.
   ResolveRequest req1(host_resolver, "a", 80, &verifier);
 
   // |verifier| will send quit message once all the requests have finished.
   MessageLoop::current()->Run();
@@ skipping 63 matching lines @@
   std::vector<StartOrCancelEntry> start_log;
   std::vector<FinishEntry> finish_log;
   std::vector<StartOrCancelEntry> cancel_log;
 };
 
 // Test that registering, unregistering, and notifying of observers works.
 // Does not test the cancellation notification since all resolves are
 // synchronous.
 TEST_F(HostResolverImplTest, Observers) {
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(NULL, kMaxCacheEntries, kMaxCacheAgeMs));
+      new HostResolverImpl(NULL, CreateDefaultCache()));
 
   CapturingObserver observer;
 
   host_resolver->AddObserver(&observer);
 
   AddressList addrlist;
 
   // Resolve "host1".
   HostResolver::RequestInfo info1("host1", 70);
   scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
@@ skipping 65 matching lines @@
 
 // Tests that observers are sent OnCancelResolution() whenever a request is
 // cancelled. There are two ways to cancel a request:
 //  (1) Delete the HostResolver while job is outstanding.
 //  (2) Call HostResolver::CancelRequest() while a request is outstanding.
 TEST_F(HostResolverImplTest, CancellationObserver) {
   CapturingObserver observer;
   {
     // Create a host resolver and attach an observer.
     scoped_refptr<HostResolver> host_resolver(
-        new HostResolverImpl(NULL, kMaxCacheEntries, kMaxCacheAgeMs));
+        new HostResolverImpl(NULL, CreateDefaultCache()));
     host_resolver->AddObserver(&observer);
 
     TestCompletionCallback callback;
 
     EXPECT_EQ(0U, observer.start_log.size());
     EXPECT_EQ(0U, observer.finish_log.size());
     EXPECT_EQ(0U, observer.cancel_log.size());
 
     // Start an async resolve for (host1:70).
     HostResolver::RequestInfo info1("host1", 70);
@@ skipping 44 matching lines @@
   EXPECT_EQ(0U, observer.finish_log.size());
   EXPECT_EQ(2U, observer.cancel_log.size());
 
   HostResolver::RequestInfo info("host2", 60);
   EXPECT_TRUE(observer.cancel_log[1] ==
               CapturingObserver::StartOrCancelEntry(1, info));
 }
 
 }  // namespace
 }  // namespace net