DNS: Expose stale results through HostResolverImpl.

net/dns/host_resolver_impl.h

 // 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.
 
 #ifndef NET_DNS_HOST_RESOLVER_IMPL_H_
 #define NET_DNS_HOST_RESOLVER_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 119 matching lines @@
   // NetworkChangeNotifier.
   void SetDnsClient(std::unique_ptr<DnsClient> dns_client);
 
   // HostResolver methods:
   int Resolve(const RequestInfo& info,
               RequestPriority priority,
               AddressList* addresses,
               const CompletionCallback& callback,
               RequestHandle* out_req,
               const BoundNetLog& source_net_log) override;
+  void ChangeRequestPriority(RequestHandle req,
+                             RequestPriority priority) override;
+  void CancelRequest(RequestHandle req) override;
   int ResolveFromCache(const RequestInfo& info,
                        AddressList* addresses,
                        const BoundNetLog& source_net_log) override;
-  void ChangeRequestPriority(RequestHandle req,
-                             RequestPriority priority) override;
-  void CancelRequest(RequestHandle req) override;
+  int ResolveStaleFromCache(const RequestInfo& info,
+                            AddressList* addresses,
+                            HostCache::EntryStaleness* stale_info,
+                            const BoundNetLog& source_net_log) override;
   void SetDnsClientEnabled(bool enabled) override;
   HostCache* GetHostCache() override;
   std::unique_ptr<base::Value> GetDnsConfigAsValue() const override;
 
   void set_proc_params_for_test(const ProcTaskParams& proc_params) {
     proc_params_ = proc_params;
   }
 
  private:
   friend class HostResolverImplTest;
   class Job;
   class ProcTask;
   class LoopbackProbeJob;
   class DnsTask;
   class Request;
   typedef HostCache::Key Key;
   typedef std::map<Key, Job*> JobMap;
 
   // Number of consecutive failures of DnsTask (with successful fallback to
   // ProcTask) before the DnsClient is disabled until the next DNS change.
   static const unsigned kMaximumDnsFailures;
 
   // Helper used by |Resolve()| and |ResolveFromCache()|.  Performs IP
   // literal, cache and HOSTS lookup (if enabled), returns OK if successful,
   // ERR_NAME_NOT_RESOLVED if either hostname is invalid or IP literal is
   // incompatible, ERR_DNS_CACHE_MISS if entry was not found in cache and
   // HOSTS and is not localhost.
+  //
+  // If |stale_info| is non-null, then stale cache entries can be returned, and
+  // |*stale_info| will be filled in with details of the entry's staleness (if
+  // an entry, fresh or stale, was returned).

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

I think this comment needs to be updated?  |allow_stale| now controls if stale
entries may be returned (yay!).  Ditto below.

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

Done.

   int ResolveHelper(const Key& key,
                     const RequestInfo& info,
                     const IPAddress* ip_address,
                     AddressList* addresses,
+                    bool allow_stale,
+                    HostCache::EntryStaleness* stale_info,
                     const BoundNetLog& request_net_log);
 
   // Tries to resolve |key| as an IP, returns true and sets |net_error| if
   // succeeds, returns false otherwise.
   bool ResolveAsIP(const Key& key,
                    const RequestInfo& info,
                    const IPAddress* ip_address,
                    int* net_error,
                    AddressList* addresses);
 
   // If |key| is not found in cache returns false, otherwise returns
   // true, sets |net_error| to the cached error code and fills |addresses|
   // if it is a positive entry.
+  //
+  // If |stale_info| is non-null, then stale cache entries can be returned, and
+  // |*stale_info| will be filled in with details of the entry's staleness (if
+  // an entry, fresh or stale, was returned).
   bool ServeFromCache(const Key& key,
                       const RequestInfo& info,
                       int* net_error,
-                      AddressList* addresses);
+                      AddressList* addresses,
+                      bool allow_stale,
+                      HostCache::EntryStaleness* stale_info);
 
   // If we have a DnsClient with a valid DnsConfig, and |key| is found in the
   // HOSTS file, returns true and fills |addresses|. Otherwise returns false.
   bool ServeFromHosts(const Key& key,
                       const RequestInfo& info,
                       AddressList* addresses);
 
   // If |key| is for a localhost name (RFC 6761), returns true and fills
   // |addresses| with the loopback IP. Otherwise returns false.
   bool ServeLocalhost(const Key& key,
@@ skipping 122 matching lines @@
 // This function is only exposed so it can be unit-tested.
 // TODO(tfarina): It would be better to change the tests so this function
 // gets exercised indirectly through HostResolverImpl.
 NET_EXPORT_PRIVATE bool ResolveLocalHostname(base::StringPiece host,
                                              uint16_t port,
                                              AddressList* address_list);
 
 }  // namespace net
 
 #endif  // NET_DNS_HOST_RESOLVER_IMPL_H_