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 <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 {
+    // 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);
+
+  // Cancels all pending calls to Resolve, and does not call their callbacks.
+  ~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,
+              RequestHandle* out_req,
+              const net::BoundNetLog& net_log) override;
+
+  void CancelRequest(RequestHandle req) 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 Request;
+
+  void OnRequestComplete(Request* request,

[xunjieli, 2016/06/13 19:25:04]

Need documentation.

[Julia Tuttle, 2016/06/14 23:11:32]

Done.

+                         const net::CompletionCallback& outer_callback,
+                         int error);
+
+  std::unique_ptr<net::HostResolverImpl> resolver_;
+  StaleOptions options_;
+  std::set<Request*> pending_requests_;

[xunjieli, 2016/06/13 19:25:04]

need documentation.

[Julia Tuttle, 2016/06/14 23:11:32]

Done.

+};
+
+}  // namespace cronet
+
+#endif  // COMPONENTS_CRONET_STALE_HOST_RESOLVER_H_