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.
+  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) {
 }
 
 void HostResolver::ChangeRequestPriority(RequestHandle req,
                                          RequestPriority priority) {
   NOTIMPLEMENTED();
 }
 
 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