Cronet: Use stale DNS cache entries experimentally.

components/cronet/stale_host_resolver.h

+// Copyright 2016 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 COMPONENTS_CRONET_STALE_HOST_RESOLVER_H_
+#define COMPONENTS_CRONET_STALE_HOST_RESOLVER_H_
+
+#include <unordered_set>
+
+#include "net/dns/host_resolver.h"
+#include "net/dns/host_resolver_impl.h"
+
+namespace cronet {
+
+// A HostResolver that wraps a HostResolverImpl and uses it to make requests,
+// but "impatiently" returns stale data (if available and usable) after a delay,
+// to reduce DNS latency at the expense of accuracy.
+class NET_EXPORT StaleHostResolver : public net::HostResolver {
+ public:
+  struct NET_EXPORT StaleOptions {
+    StaleOptions();
+
+    // How long to wait before returning stale data, if available.
+    base::TimeDelta delay;
+
+    // If positive, how long stale data can be past the expiration time before
+    // it's considered unusable. If zero or negative, stale data can be used
+    // indefinitely.
+    base::TimeDelta max_expired_time;
+
+    // If set, stale data from previous networks is usable; if clear, it's not.
+    //
+    // If the other network had a working, correct DNS setup, this can increase
+    // the availability of useful stale results.
+    //
+    // If the other network had a broken (e.g. hijacked for captive portal) DNS
+    // setup, this will instead end up returning useless results.
+    bool allow_other_network;
+
+    // If positive, the maximum number of times a stale entry can be used. If
+    // zero, there is no limit.
+    int max_stale_uses;
+  };
+
+  // Creates a StaleHostResolver that uses |inner_resolver| for actual
+  // resolution, but potentially returns stale data according to
+  // |stale_options|.
+  StaleHostResolver(std::unique_ptr<net::HostResolverImpl> inner_resolver,
+                    const StaleOptions& stale_options);
+
+  ~StaleHostResolver() override;
+
+  // HostResolver implementation:
+
+  // Resolves as a regular HostResolver, but if stale data is available and
+  // usable (according to the options passed to the constructor), and fresh data
+  // is not returned before the specified delay, returns the stale data instead.
+  //
+  // If stale data is returned, the StaleHostResolver allows the underlying
+  // request to continue in order to repopulate the cache.
+  int Resolve(const RequestInfo& info,
+              net::RequestPriority priority,
+              net::AddressList* addresses,
+              const net::CompletionCallback& callback,
+              std::unique_ptr<Request>* out_req,
+              const net::BoundNetLog& net_log) override;
+
+  // The remaining public methods pass through to the inner resolver:
+
+  int ResolveFromCache(const RequestInfo& info,
+                       net::AddressList* addresses,
+                       const net::BoundNetLog& net_log) override;
+  void SetDnsClientEnabled(bool enabled) override;
+  net::HostCache* GetHostCache() override;
+  std::unique_ptr<base::Value> GetDnsConfigAsValue() const override;
+
+ private:
+  class RequestImpl;
+
+  // Called from |Request| when a request is complete and can be destroyed.
+  void OnRequestComplete(Request* request);
+
+  // The underlying HostResolverImpl that will be used to make cache and network
+  // requests.
+  std::unique_ptr<net::HostResolverImpl> inner_resolver_;
+
+  // Options that govern when a stale response can or can't be returned.
+  StaleOptions options_;
+
+  DISALLOW_COPY_AND_ASSIGN(StaleHostResolver);
+};
+
+}  // namespace cronet
+
+#endif  // COMPONENTS_CRONET_STALE_HOST_RESOLVER_H_