DNS: Expose stale results through HostResolverImpl.

net/dns/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/dns/host_resolver_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <tuple>
@@ skipping 193 matching lines @@
  public:
   // Base class of handlers to be executed on completion of requests.
   struct Handler {
     virtual ~Handler() {}
     virtual void Handle(Request* request) = 0;
   };
 
   Request(const HostResolver::RequestInfo& info,
           RequestPriority priority,
           size_t index,
-          HostResolver* resolver,
+          HostResolverImpl* resolver,
           Handler* handler)
       : info_(info),
         priority_(priority),
         index_(index),
         resolver_(resolver),
         handler_(handler),
         quit_on_complete_(false),
         result_(ERR_UNEXPECTED),
         handle_(NULL) {}
 
@@ skipping 12 matching lines @@
       EXPECT_EQ(OK, result_);
     return result_;
   }
 
   int ResolveFromCache() {
     DCHECK(resolver_);
     DCHECK(!handle_);
     return resolver_->ResolveFromCache(info_, &list_, BoundNetLog());
   }
 
+  int ResolveStaleFromCache() {
+    DCHECK(resolver_);
+    DCHECK(!handle_);
+    return resolver_->ResolveStaleFromCache(info_, &list_, &staleness_,
+                                            BoundNetLog());
+  }
+
   void ChangePriority(RequestPriority priority) {
     DCHECK(resolver_);
     DCHECK(handle_);
     resolver_->ChangeRequestPriority(handle_, priority);
     priority_ = priority;
   }
 
   void Cancel() {
     DCHECK(resolver_);
     DCHECK(handle_);
     resolver_->CancelRequest(handle_);
     handle_ = NULL;
   }
 
   const HostResolver::RequestInfo& info() const { return info_; }
   size_t index() const { return index_; }
   const AddressList& list() const { return list_; }
   int result() const { return result_; }
+  const HostCache::EntryStaleness staleness() const { return staleness_; }
   bool completed() const { return result_ != ERR_IO_PENDING; }
   bool pending() const { return handle_ != NULL; }
 
   bool HasAddress(const std::string& address, uint16_t port) const {
     return AddressListContains(list_, address, port);
   }
 
   // Returns the number of addresses in |list_|.
   unsigned NumberOfAddresses() const {
     return list_.size();
@@ skipping 36 matching lines @@
       handler_->Handle(this);
     if (quit_on_complete_) {
       base::MessageLoop::current()->QuitWhenIdle();
       quit_on_complete_ = false;
     }
   }
 
   HostResolver::RequestInfo info_;
   RequestPriority priority_;
   size_t index_;
-  HostResolver* resolver_;
+  HostResolverImpl* resolver_;
   Handler* handler_;
   bool quit_on_complete_;
 
   AddressList list_;
   int result_;
   HostResolver::RequestHandle handle_;
+  HostCache::EntryStaleness staleness_;
 
   DISALLOW_COPY_AND_ASSIGN(Request);
 };
 
 // Using LookupAttemptHostResolverProc simulate very long lookups, and control
 // which attempt resolves the host.
 class LookupAttemptHostResolverProc : public HostResolverProc {
  public:
   LookupAttemptHostResolverProc(HostResolverProc* previous,
                                 int attempt_number_to_resolve,
@@ skipping 260 matching lines @@
   }
 
   static unsigned maximum_dns_failures() {
     return HostResolverImpl::kMaximumDnsFailures;
   }
 
   bool IsIPv6Reachable(const BoundNetLog& net_log) {
     return resolver_->IsIPv6Reachable(net_log);
   }
 
+  void MakeCacheStale() {
+    DCHECK(resolver_.get());
+    resolver_->GetHostCache()->OnNetworkChange();
+  }
+
   scoped_refptr<MockHostResolverProc> proc_;
   std::unique_ptr<HostResolverImpl> resolver_;
   std::vector<std::unique_ptr<Request>> requests_;
 
   std::unique_ptr<Handler> handler_;
 };
 
 TEST_F(HostResolverImplTest, AsynchronousLookup) {
   proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
   proc_->SignalMultiple(1u);
@@ skipping 754 matching lines @@
 
   // This time, we fetch normally.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info, DEFAULT_PRIORITY)->Resolve());
   EXPECT_EQ(OK, requests_[1]->WaitForResult());
 
   // Now we should be able to fetch from the cache.
   EXPECT_EQ(OK, CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80));
 }
 
+TEST_F(HostResolverImplTest, ResolveStaleFromCache) {
+  proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
+  proc_->SignalMultiple(1u);  // Need only one.
+
+  HostResolver::RequestInfo info(HostPortPair("just.testing", 80));
+
+  // First hit will miss the cache.
+  EXPECT_EQ(ERR_DNS_CACHE_MISS,
+            CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
+
+  // This time, we fetch normally.
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info, DEFAULT_PRIORITY)->Resolve());
+  EXPECT_EQ(OK, requests_[1]->WaitForResult());
+
+  // Now we should be able to fetch from the cache.
+  EXPECT_EQ(OK, CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
+  EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80));
+  EXPECT_EQ(OK, CreateRequest(info, DEFAULT_PRIORITY)->ResolveStaleFromCache());
+  EXPECT_TRUE(requests_[3]->HasOneAddress("192.168.1.42", 80));
+  EXPECT_FALSE(requests_[3]->staleness().is_stale());
+
+  MakeCacheStale();
+
+  // Now we should be able to fetch from the cache only if we use
+  // ResolveStaleFromCache.
+  EXPECT_EQ(ERR_DNS_CACHE_MISS,
+            CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
+  EXPECT_EQ(OK, CreateRequest(info, DEFAULT_PRIORITY)->ResolveStaleFromCache());
+  EXPECT_TRUE(requests_[5]->HasOneAddress("192.168.1.42", 80));
+  EXPECT_TRUE(requests_[5]->staleness().is_stale());
+}
+
 // 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;
 
   scoped_refptr<LookupAttemptHostResolverProc> resolver_proc(
@@ skipping 924 matching lines @@
   EXPECT_FALSE(ResolveLocalHostname("::1:1", kLocalhostLookupPort, &addresses));
   EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:0:0:0:0:1", kLocalhostLookupPort,
                                     &addresses));
   EXPECT_FALSE(ResolveLocalHostname("foo.localhost.com", kLocalhostLookupPort,
                                     &addresses));
   EXPECT_FALSE(
       ResolveLocalHostname("foo.localhoste", kLocalhostLookupPort, &addresses));
 }
 
 }  // namespace net