DNS: Retain stale entries in HostCache and return when requested

net/dns/host_resolver_impl.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 <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 1730 matching lines @@
     }
 
     if (num_active_requests() == 0) {
       net_log_.AddEvent(NetLog::TYPE_CANCELLED);
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
                                         OK);
       return;
     }
 
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
-                                      entry.error);
+                                      entry.error());
 
     DCHECK(!requests_.empty());
 
-    if (entry.error == OK) {
+    if (entry.error() == OK) {
       // Record this histogram here, when we know the system has a valid DNS
       // configuration.
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HaveDnsConfig",
                             resolver_->received_dns_config_);
     }
 
-    bool did_complete = (entry.error != ERR_NETWORK_CHANGED) &&
-                        (entry.error != ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);
+    bool did_complete = (entry.error() != ERR_NETWORK_CHANGED) &&
+                        (entry.error() != ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);
     if (did_complete)
       resolver_->CacheResult(key_, entry, ttl);
 
     // Complete all of the requests that were attached to the job.
     for (const std::unique_ptr<Request>& req : requests_) {
       if (req->was_canceled())
         continue;
 
       DCHECK_EQ(this, req->job());
       // Update the net log and notify registered observers.
-      LogFinishRequest(req->source_net_log(), req->info(), entry.error);
+      LogFinishRequest(req->source_net_log(), req->info(), entry.error());
       if (did_complete) {
         // Record effective total time from creation to completion.
         RecordTotalTime(had_dns_config_, req->info().is_speculative(),
                         base::TimeTicks::Now() - req->request_time());
       }
-      req->OnComplete(entry.error, entry.addrlist);
+      req->OnComplete(entry.error(), entry.addresses());
 
       // Check if the resolver was destroyed as a result of running the
       // callback. If it was, we could continue, but we choose to bail.
       if (!resolver_.get())
         return;
     }
   }
 
   // Convenience wrapper for CompleteRequests in case of failure.
   void CompleteRequestsWithError(int net_error) {
@@ skipping 343 matching lines @@
   DCHECK(addresses);
   DCHECK(net_error);
   if (!info.allow_cached_response() || !cache_.get())
     return false;
 
   const HostCache::Entry* cache_entry = cache_->Lookup(
       key, base::TimeTicks::Now());
   if (!cache_entry)
     return false;
 
-  *net_error = cache_entry->error;
+  *net_error = cache_entry->error();
   if (*net_error == OK) {
     if (cache_entry->has_ttl())
-      RecordTTL(cache_entry->ttl);
-    *addresses = EnsurePortOnAddressList(cache_entry->addrlist, info.port());
+      RecordTTL(cache_entry->ttl());
+    *addresses = EnsurePortOnAddressList(cache_entry->addresses(), info.port());
   }
   return true;
 }
 
 bool HostResolverImpl::ServeFromHosts(const Key& key,
                                       const RequestInfo& info,
                                       AddressList* addresses) {
   DCHECK(addresses);
   if (!HaveDnsConfig())
     return false;
@@ skipping 323 matching lines @@
     dns_client_->SetConfig(dns_config);
     num_dns_failures_ = 0;
     if (dns_client_->GetConfig())
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
   }
 
   AbortDnsTasks();
 }
 
 }  // namespace net