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 abe8e49e6578714bf5216398b3450135b4798da1..de8a8785aa765a5ec0d9e9adb357dbe4e3f718f9 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,11 +101,47 @@ 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.
+  stale_info->expired_by = base::TimeDelta::FromSeconds(-1);
+  stale_info->network_changes = 0u;
+  stale_info->stale_hits = 0u;
+  return ResolveFromCache(info, addresses, net_log);
+}
+
+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) {
+  int rv = ResolveStaleFromCache(info, addresses, stale_info, net_log);
+  // If it's a fresh cache hit, return it synchronously.
+  if (rv != ERR_DNS_CACHE_MISS && !stale_info->is_stale()) {
+    *stale_error = ERR_UNEXPECTED;
+    stale_addresses->clear();
+    return rv;
+  }
+
+  *stale_error = rv;
+  *stale_addresses = *addresses;

[Randy Smith (Not in Mondays), 2016/05/04 19:46:59]

I wince a bit at setting *stale_addresses in the ERR_DNS_CACHE_MISS case, since
nothing was returned in that case.

[Julia Tuttle, 2016/05/05 15:42:54]

Fixed.

+  addresses->clear();

[Randy Smith (Not in Mondays), 2016/05/04 19:46:59]

So both this and the ResolveStaleFromCache() call above mean that the function
may alter |*addresses| when it's not actually returning fresh information
synchronously.  I could imagine this being surprising behavior to the caller, so
I'd suggest avoiding it even though it makes the implementation more complicated
(I neither think the caller should rely on *addresses not being modified nor
that the implementation should modify it, if synchronous fresh results aren't
being returned).

[Julia Tuttle, 2016/05/05 15:42:54]

Fixed.

+
+  return Resolve(info, priority, addresses, callback, out_req, net_log);
+}
+
 void HostResolver::SetDnsClientEnabled(bool enabled) {
 }
 
 HostCache* HostResolver::GetHostCache() {
-  return NULL;
+  return nullptr;
 }
 
 std::unique_ptr<base::Value> HostResolver::GetDnsConfigAsValue() const {