DNS: Let requests specify a callback for future cache hits

net/dns/host_resolver.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_H_
 #define NET_DNS_HOST_RESOLVER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 46 matching lines @@
     size_t max_concurrent_resolves;
     size_t max_retry_attempts;
     bool enable_caching;
   };
 
   // The parameters for doing a Resolve(). A hostname and port are
   // required; the rest are optional (and have reasonable defaults).
   class NET_EXPORT RequestInfo {
    public:
     explicit RequestInfo(const HostPortPair& host_port_pair);
+    RequestInfo(const RequestInfo& request_info);
+    ~RequestInfo();
 
     const HostPortPair& host_port_pair() const { return host_port_pair_; }
     void set_host_port_pair(const HostPortPair& host_port_pair) {
       host_port_pair_ = host_port_pair;
     }
 
     uint16_t port() const { return host_port_pair_.port(); }
     const std::string& hostname() const { return host_port_pair_.host(); }
 
     AddressFamily address_family() const { return address_family_; }
@@ skipping 10 matching lines @@
 
     bool allow_cached_response() const { return allow_cached_response_; }
     void set_allow_cached_response(bool b) { allow_cached_response_ = b; }
 
     bool is_speculative() const { return is_speculative_; }
     void set_is_speculative(bool b) { is_speculative_ = b; }
 
     bool is_my_ip_address() const { return is_my_ip_address_; }
     void set_is_my_ip_address(bool b) { is_my_ip_address_ = b; }
 
+    using CacheHitCallback = base::Callback<void(const RequestInfo&)>;
+    const CacheHitCallback& cache_hit_callback() const {
+      return cache_hit_callback_;
+    }
+    void set_cache_hit_callback(const CacheHitCallback& callback) {
+      cache_hit_callback_ = callback;
+    }
+
    private:
+    RequestInfo();
+
     // The hostname to resolve, and the port to use in resulting sockaddrs.
     HostPortPair host_port_pair_;
 
     // The address family to restrict results to.
     AddressFamily address_family_;
 
     // Flags to use when resolving this request.
     HostResolverFlags host_resolver_flags_;
 
     // Whether it is ok to return a result from the host cache.
     bool allow_cached_response_;
 
     // Whether this request was started by the DNS prefetcher.
     bool is_speculative_;
 
     // Indicates a request for myIpAddress (to differentiate from other requests
     // for localhost, currently used by Chrome OS).
     bool is_my_ip_address_;
+
+    // A callback that will be called when another request reads the cache data
+    // returned (and possibly written) by this request.
+    CacheHitCallback cache_hit_callback_;
   };
 
   // Opaque type used to cancel a request.
   typedef void* RequestHandle;
 
   // Set Options.max_concurrent_resolves to this to select a default level
   // of concurrency.
   static const size_t kDefaultParallelism = 0;
 
   // Set Options.max_retry_attempts to this to select a default retry value.
@@ skipping 73 matching lines @@
  protected:
   HostResolver();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HostResolver);
 };
 
 }  // namespace net
 
 #endif  // NET_DNS_HOST_RESOLVER_H_