DNS: Expose stale results through HostResolverImpl.

net/dns/host_resolver.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.h"
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #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"
 #include "net/dns/host_resolver_impl.h"
 
 namespace net {
 
 namespace {
 
 // Maximum of 6 concurrent resolver threads (excluding retries).
@@ skipping 71 matching lines @@
     : host_port_pair_(host_port_pair),
       address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       host_resolver_flags_(0),
       allow_cached_response_(true),
       is_speculative_(false),
       is_my_ip_address_(false) {}
 
 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 {
   return nullptr;
 }
 
 // static
 std::unique_ptr<HostResolver> HostResolver::CreateSystemResolver(
     const Options& options,
     NetLog* net_log) {
   return std::unique_ptr<HostResolver>(new HostResolverImpl(options, net_log));
 }
 
 // static
 std::unique_ptr<HostResolver> HostResolver::CreateDefaultResolver(
     NetLog* net_log) {
   return std::unique_ptr<HostResolver>(
       new HostResolverImpl(Options(), net_log));
 }
 
 HostResolver::HostResolver() {
 }
 
 }  // namespace net