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 120 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;
   void SetDnsClientEnabled(bool enabled) override;
   HostCache* GetHostCache() override;
   std::unique_ptr<base::Value> GetDnsConfigAsValue() const override;
 
+  // Like |ResolveFromCache()|, but can return a stale result if the
+  // implementation supports it. Fills in |*stale_info| if a response is
+  // returned to indicate how stale (or not) it is.
+  int ResolveStaleFromCache(const RequestInfo& info,
+                            AddressList* addresses,
+                            HostCache::EntryStaleness* stale_info,
+                            const BoundNetLog& source_net_log);
+
   void set_proc_params_for_test(const ProcTaskParams& proc_params) {
     proc_params_ = proc_params;
   }
 
  protected:
   // Just like the public constructor, but allows the task runner used for
   // blocking tasks to be specified. Intended for testing only.
   HostResolverImpl(const Options& options,
                    NetLog* net_log,
                    scoped_refptr<base::TaskRunner> worker_task_runner);
@@ skipping 13 matching lines @@
 
   // 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 |allow_stale| is true, then stale cache entries can be returned.
+  // |stale_info| must be non-null, and will be filled in with details of the
+  // entry's staleness (if an entry is returned).
+  //
+  // If |allow_stale| is false, then stale cache entries will not be returned,
+  // and |stale_info| must be null.
   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 |allow_stale| is true, then stale cache entries can be returned.
+  // |stale_info| must be non-null, and will be filled in with details of the
+  // entry's staleness (if an entry is returned).
+  //
+  // If |allow_stale| is false, then stale cache entries will not be returned,
+  // and |stale_info| must be null.
   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 127 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_