DNS: Expose stale results through HostResolverImpl.

net/dns/host_resolver.cc

Index: net/dns/host_resolver.cc
diff --git a/net/dns/host_resolver.cc b/net/dns/host_resolver.cc
index f0a751e767df0f71dcd42acc1051effa72616b58..b553578d6b315e285150a4466eb2683eb28cc97b 100644
--- a/net/dns/host_resolver.cc
+++ b/net/dns/host_resolver.cc
@@ -9,6 +9,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/values.h"
+#include "net/base/net_errors.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_config_service.h"
 #include "net/dns/host_cache.h"
@@ -100,6 +101,54 @@ HostResolver::RequestInfo::RequestInfo(const HostPortPair& host_port_pair)
 HostResolver::~HostResolver() {
 }
 
+int HostResolver::ResolveStaleFromCache(const RequestInfo& info,
+                                        AddressList* addresses,
+                                        HostCache::EntryStaleness* stale_info,
+                                        const BoundNetLog& net_log) {
+  // If a resolver doesn't know how to get potentially-stale results from the
+  // cache, blank |*stale_info| and just get fresh results instead.
+  int rv = ResolveFromCache(info, addresses, net_log);
+  if (rv != ERR_DNS_CACHE_MISS) {
+    stale_info->expired_by = base::TimeDelta::FromSeconds(-1);
+    stale_info->network_changes = 0u;
+    stale_info->stale_hits = 0u;
+  }
+  return rv;
+}
+
+int HostResolver::ResolveStale(const RequestInfo& info,
+                               RequestPriority priority,
+                               AddressList* addresses,
+                               const CompletionCallback& callback,
+                               RequestHandle* out_req,
+                               int* stale_error,
+                               AddressList* stale_addresses,
+                               HostCache::EntryStaleness* stale_info,
+                               const BoundNetLog& net_log) {
+  AddressList cache_addresses;
+  int cache_rv =
+      ResolveStaleFromCache(info, &cache_addresses, stale_info, net_log);
+  // If it's a fresh cache hit (or literal), return it synchronously.
+  if (cache_rv != ERR_DNS_CACHE_MISS && !stale_info->is_stale()) {
+    *stale_error = ERR_UNEXPECTED;

[Randy Smith (Not in Mondays), 2016/05/17 20:39:35]

Why set |*stale_error| if it isn't stale?  Isn't that against the interface
spec?

[Julia Tuttle, 2016/05/20 17:54:42]

It's mostly defensive -- if someone accidentally gets the logic wrong and acts
on |*stale_error|, I want them to return a known-bogus error instead of
potentially returning a random error or erroneous results based on whatever was
left there.

I'm moving this into StaleHostResolver, so it will no longer be against a spec
promise I'm making to other callers.

+    *addresses = cache_addresses;
+    return cache_rv;
+  }
+
+  // If it's a stale cache hit, fill in |*stale_addresses| but run the network
+  // request anyway.
+  if (cache_rv != ERR_DNS_CACHE_MISS)
+    *stale_addresses = cache_addresses;
+
+  *stale_error = cache_rv;
+
+  // Don't check the cache again.
+  RequestInfo no_cache_info(info);
+  no_cache_info.set_allow_cached_response(false);
+  return Resolve(no_cache_info, priority, addresses, callback, out_req,
+                 net_log);
+}
+
 void HostResolver::SetDnsClientEnabled(bool enabled) {
 }
 
@@ -109,7 +158,7 @@ void HostResolver::ChangeRequestPriority(RequestHandle req,
 }
 
 HostCache* HostResolver::GetHostCache() {
-  return NULL;
+  return nullptr;
 }
 
 std::unique_ptr<base::Value> HostResolver::GetDnsConfigAsValue() const {