Cronet: Use stale DNS cache entries experimentally.

components/cronet/stale_host_resolver.cc

Index: components/cronet/stale_host_resolver.cc
diff --git a/components/cronet/stale_host_resolver.cc b/components/cronet/stale_host_resolver.cc
new file mode 100644
index 0000000000000000000000000000000000000000..22e5cd6c4d0496f5b95459a5436e3a3f8bff9fa2
--- /dev/null
+++ b/components/cronet/stale_host_resolver.cc
@@ -0,0 +1,400 @@
+// 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.
+
+#include "components/cronet/stale_host_resolver.h"
+
+#include "base/callback_helpers.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/stl_util.h"
+#include "base/timer/timer.h"
+#include "base/values.h"
+#include "net/base/net_errors.h"
+#include "net/dns/dns_util.h"
+#include "net/dns/host_resolver_impl.h"
+
+namespace cronet {
+
+namespace {
+
+// Used in histograms; do not modify existing values.
+enum RequestOutcome {
+  // Served from (valid) cache, hosts file, IP literal, etc.
+  SYNCHRONOUS = 0,
+
+  // Network responded; there was no usable stale data.
+  NETWORK_WITHOUT_STALE = 1,
+
+  // Network responded before stale delay; there was usable stale data.
+  NETWORK_WITH_STALE = 2,
+
+  // Stale data returned; network didn't respond before the stale delay.
+  STALE_BEFORE_NETWORK = 3,
+
+  // Request canceled; there was no usable stale data.
+  CANCELED_WITHOUT_STALE = 4,
+
+  // Request canceled; there was usable stale data.
+  CANCELED_WITH_STALE = 5,
+
+  MAX_REQUEST_OUTCOME
+};
+
+void RecordRequestOutcome(RequestOutcome outcome) {
+  UMA_HISTOGRAM_ENUMERATION("DNS.StaleHostResolver.RequestOutcome", outcome,
+                            MAX_REQUEST_OUTCOME);
+}
+
+void RecordAddressListDelta(net::AddressListDeltaType delta) {
+  UMA_HISTOGRAM_ENUMERATION("DNS.StaleHostResolver.StaleAddressListDelta",
+                            delta, net::MAX_DELTA_TYPE);
+}
+
+void RecordTimeDelta(base::TimeTicks network_time, base::TimeTicks stale_time) {
+  if (network_time < stale_time) {
+    UMA_HISTOGRAM_MEDIUM_TIMES("DNS.StaleHostResolver.NetworkEarly",
+                               stale_time - network_time);
+  } else {
+    UMA_HISTOGRAM_MEDIUM_TIMES("DNS.StaleHostResolver.NetworkLate",
+                               network_time - stale_time);
+  }
+}
+
+bool StaleEntryIsUsable(const StaleHostResolver::StaleOptions& options,
+                        const net::HostCache::EntryStaleness& entry) {
+  if (options.max_expired_time != base::TimeDelta() &&
+      entry.expired_by > options.max_expired_time) {
+    return false;
+  }
+  if (options.max_stale_uses > 0 && entry.stale_hits > options.max_stale_uses)
+    return false;
+  if (!options.allow_other_network && entry.network_changes > 0)
+    return false;
+  return true;
+}
+
+}  // namespace
+
+// A request made by the StaleHostResolver. May return fresh cached data,
+// network data, or stale cached data.
+//
+// Expected lifetime:
+// 1. Request constructed.
+// 2. Request started with |Start()|. If |Start()| returns ERR_IO_PENDING:
+//    a) Request calls |result_callback| *OR* Request is canceled with
+//       |Cancel()|.
+//    b) Request calls |complete_callback| passed to Start.
+// 4. Request destroyed.
+class StaleHostResolver::Request {
+ public:
+  Request(net::HostResolverImpl* resolver);
+  ~Request();
+
+  // A callback for the caller to decide whether a stale entry is usable or not.
+  typedef base::Callback<bool(const net::HostCache::EntryStaleness&)>
+      StaleEntryUsableCallback;
+
+  // Starts the request. May call |usable_callback| inline if |resolver| returns
+  // stale data to let the caller decide whether the data is usable.
+  //
+  // Returns the result if the request finishes synchronously. Returns
+  // ERR_IO_PENDING and calls |result_callback| with the result if it finishes
+  // asynchronously and was not canceled (via |Cancel()|).
+  //
+  // If the request does not finish synchronously, also calls
+  // |complete_callback| once a result has been returned *and* the underlying
+  // network request is complete, so the caller can destroy the Request.
+  //
+  // |addresses| must remain valid until the Request completes (synchronously or
+  // via |result_callback|) or is canceled (via |Cancel()|).
+  int Start(const RequestInfo& info,
+            net::RequestPriority priority,
+            net::AddressList* addresses,
+            const net::CompletionCallback& result_callback,
+            const net::BoundNetLog& net_log,
+            const StaleEntryUsableCallback& usable_callback,
+            base::TimeDelta stale_delay,
+            const base::Callback<void()>& complete_callback);
+
+  // Cancels the Request. |Start()| must have been called and returned
+  // ERR_IO_PENDING; the request must not have been canceled already.
+  //
+  // Does not call |result_callback|, but does call |complete_callback|.
+  void Cancel();
+
+  bool network_request_running() const { return network_handle_ != nullptr; }
+
+ private:
+  // Callback for |stale_timer_| that returns stale results.
+  void OnStaleDelayElapsed();
+  // Callback for network request that returns fresh results if the request
+  // hasn't already returned stale results, and completes the request.
+  void OnNetworkRequestComplete(int error);
+  // Fills |*addresses_| if rv is OK and returns rv.
+  int HandleResult(int rv, const net::AddressList& addresses);
+  // Fills |*addresses_| if rv is OK and calls |result_callback_| with rv.
+  void ReturnResult(int rv, const net::AddressList& addresses);
+  // Calls |complete_callback_|.
+  void Complete();
+
+  void RecordSynchronousRequest();
+  void RecordNetworkRequest(int error);
+  void RecordCanceledRequest();
+
+  bool returned_stale_result() const { return result_callback_.is_null(); }
+
+  net::HostResolverImpl* resolver_;
+
+  // The address list passed into |Start()| to be filled in when the request
+  // returns.
+  net::AddressList* addresses_;
+  // The callback passed into |Start()| to be called when the request returns.
+  net::CompletionCallback result_callback_;
+
+  // The error from the stale cache entry, if there was one.
+  int stale_error_;
+  // The address list from the stale cache entry, if there was one.
+  net::AddressList stale_addresses_;
+  // A timer that fires when the |Request| should return stale results, if the
+  // underlying network request has not finished yet.
+  base::OneShotTimer stale_timer_;
+
+  // The address list the underlying network request will fill in. (Can't be the
+  // one passed to |Start()|, or else the network request would overwrite stale
+  // results after they are returned.)
+  net::AddressList network_addresses_;
+  // The request handle to the underlying network request, so it can be canceled
+  // in |Cancel()| or the destructor.
+  net::HostResolver::RequestHandle network_handle_;
+
+  // The callback passed into |Start()| to be called when the Request is
+  // entirely complete (has returned or been canceled, and the underlying
+  // network request has also returned or been canceled).
+  base::Callback<void()> complete_callback_;
+};
+
+StaleHostResolver::Request::Request(net::HostResolverImpl* resolver)
+    : resolver_(resolver),
+      addresses_(nullptr),
+      stale_error_(net::ERR_DNS_CACHE_MISS),
+      network_handle_(nullptr) {}
+
+StaleHostResolver::Request::~Request() {
+  if (network_request_running())
+    resolver_->CancelRequest(network_handle_);

[xunjieli, 2016/07/25 17:18:14]

Out of paranoia, could you also do "network_handle_ = nullptr;" here?

[Julia Tuttle, 2016/07/25 19:29:15]

Done.

+}
+
+int StaleHostResolver::Request::Start(
+    const RequestInfo& info,
+    net::RequestPriority priority,
+    net::AddressList* addresses,
+    const net::CompletionCallback& result_callback,
+    const net::BoundNetLog& net_log,
+    const StaleEntryUsableCallback& usable_callback,
+    base::TimeDelta stale_delay,
+    const base::Callback<void()>& complete_callback) {
+  DCHECK(!result_callback.is_null());
+  DCHECK(!usable_callback.is_null());
+  DCHECK(!complete_callback.is_null());
+
+  addresses_ = addresses;
+
+  net::AddressList cache_addresses;
+  net::HostCache::EntryStaleness stale_info;
+  int cache_rv = resolver_->ResolveStaleFromCache(info, &cache_addresses,
+                                                  &stale_info, net_log);
+  // If it's a fresh cache hit (or literal), return it synchronously.
+  if (cache_rv != net::ERR_DNS_CACHE_MISS && !stale_info.is_stale()) {
+    cache_rv = HandleResult(cache_rv, cache_addresses);
+    RecordSynchronousRequest();
+    return cache_rv;
+  }
+
+  result_callback_ = result_callback;
+  complete_callback_ = complete_callback;
+
+  if (cache_rv != net::ERR_DNS_CACHE_MISS && usable_callback.Run(stale_info)) {
+    stale_error_ = cache_rv;
+    stale_addresses_ = cache_addresses;
+    // |stale_timer_| is deleted when the Request is deleted, so it's safe to
+    // use Unretained here.
+    base::Callback<void()> stale_callback =
+        base::Bind(&StaleHostResolver::Request::OnStaleDelayElapsed,
+                   base::Unretained(this));
+    stale_timer_.Start(FROM_HERE, stale_delay, stale_callback);
+  }
+
+  // Don't check the cache again.
+  net::HostResolver::RequestInfo no_cache_info(info);
+  no_cache_info.set_allow_cached_response(false);
+  int network_rv = resolver_->Resolve(
+      no_cache_info, priority, &network_addresses_,
+      base::Bind(&StaleHostResolver::Request::OnNetworkRequestComplete,
+                 base::Unretained(this)),
+      &network_handle_, net_log);
+  DCHECK_EQ(net::ERR_IO_PENDING, network_rv);
+  return net::ERR_IO_PENDING;
+}
+
+void StaleHostResolver::Request::Cancel() {
+  DCHECK(network_request_running());
+  DCHECK(!returned_stale_result());
+
+  resolver_->CancelRequest(network_handle_);
+  network_handle_ = nullptr;
+  RecordCanceledRequest();
+  Complete();
+}
+
+void StaleHostResolver::Request::OnStaleDelayElapsed() {
+  DCHECK(network_request_running());
+  DCHECK(!returned_stale_result());
+  DCHECK_NE(net::ERR_DNS_CACHE_MISS, stale_error_);
+
+  ReturnResult(stale_error_, stale_addresses_);
+
+  stale_error_ = net::ERR_DNS_CACHE_MISS;
+
+  // Don't call |Complete()| yet; let the underlying network request continue
+  // so it backfills the cache.
+}
+
+void StaleHostResolver::Request::OnNetworkRequestComplete(int error) {
+  DCHECK(network_request_running());
+
+  network_handle_ = nullptr;
+
+  if (!returned_stale_result())
+    ReturnResult(error, network_addresses_);
+
+  RecordNetworkRequest(error);
+  Complete();
+}
+
+int StaleHostResolver::Request::HandleResult(
+    int rv,
+    const net::AddressList& addresses) {
+  DCHECK(addresses_);
+
+  if (rv == net::OK)
+    *addresses_ = addresses;
+  addresses_ = nullptr;
+  return rv;
+}
+
+void StaleHostResolver::Request::ReturnResult(
+    int rv,
+    const net::AddressList& addresses) {
+  DCHECK(!result_callback_.is_null());
+  base::ResetAndReturn(&result_callback_).Run(HandleResult(rv, addresses));
+}
+
+void StaleHostResolver::Request::Complete() {
+  DCHECK(!complete_callback_.is_null());
+  base::ResetAndReturn(&complete_callback_).Run();
+}
+
+void StaleHostResolver::Request::RecordSynchronousRequest() {
+  RecordRequestOutcome(SYNCHRONOUS);
+}
+
+void StaleHostResolver::Request::RecordNetworkRequest(int error) {
+  if (stale_timer_.IsRunning() || returned_stale_result())
+    RecordTimeDelta(base::TimeTicks::Now(), stale_timer_.desired_run_time());
+
+  if (returned_stale_result() && stale_error_ == net::OK && error == net::OK) {
+    RecordAddressListDelta(
+        FindAddressListDeltaType(stale_addresses_, network_addresses_));
+  }
+
+  if (returned_stale_result())
+    RecordRequestOutcome(STALE_BEFORE_NETWORK);
+  else if (stale_timer_.IsRunning())
+    RecordRequestOutcome(NETWORK_WITH_STALE);
+  else
+    RecordRequestOutcome(NETWORK_WITHOUT_STALE);
+}
+
+void StaleHostResolver::Request::RecordCanceledRequest() {
+  if (stale_timer_.IsRunning())
+    RecordRequestOutcome(CANCELED_WITH_STALE);
+  else
+    RecordRequestOutcome(CANCELED_WITHOUT_STALE);
+}
+
+StaleHostResolver::StaleOptions::StaleOptions()
+    : delay(),
+      max_expired_time(),
+      allow_other_network(false),
+      max_stale_uses(0) {}
+
+StaleHostResolver::StaleHostResolver(
+    std::unique_ptr<net::HostResolverImpl> inner_resolver,
+    const StaleOptions& stale_options)
+    : inner_resolver_(std::move(inner_resolver)), options_(stale_options) {
+  DCHECK_LE(0, stale_options.max_expired_time.InMicroseconds());
+  DCHECK_LE(0, stale_options.max_stale_uses);
+}
+
+StaleHostResolver::~StaleHostResolver() {
+  STLDeleteElements(&pending_requests_);
+}
+
+int StaleHostResolver::Resolve(const RequestInfo& info,
+                               net::RequestPriority priority,
+                               net::AddressList* addresses,
+                               const net::CompletionCallback& callback,
+                               RequestHandle* out_req,
+                               const net::BoundNetLog& net_log) {
+  StaleHostResolver::Request::StaleEntryUsableCallback usable_callback =
+      base::Bind(&StaleEntryIsUsable, options_);
+
+  Request* request = new Request(inner_resolver_.get());

[xunjieli, 2016/07/25 17:18:14]

If |request| completes synchronously, will we leak |request|? I don't see the
place it is cleaned up in that sync case.

[Julia Tuttle, 2016/07/25 19:29:15]

Done.

+
+  const base::Callback<void()> complete_callback = base::Bind(
+      &StaleHostResolver::OnRequestComplete, base::Unretained(this), request);
+  int rv = request->Start(info, priority, addresses, callback, net_log,
+                          usable_callback, options_.delay, complete_callback);
+  if (rv == net::ERR_IO_PENDING) {
+    pending_requests_.insert(request);
+    if (out_req)
+      *out_req = reinterpret_cast<RequestHandle>(request);
+  }
+  return rv;
+}
+
+void StaleHostResolver::CancelRequest(RequestHandle req_handle) {
+  Request* request = reinterpret_cast<Request*>(req_handle);
+  DCHECK(request);
+  DCHECK(request->network_request_running());
+
+  request->Cancel();
+}
+
+int StaleHostResolver::ResolveFromCache(const RequestInfo& info,
+                                        net::AddressList* addresses,
+                                        const net::BoundNetLog& net_log) {
+  return inner_resolver_->ResolveFromCache(info, addresses, net_log);
+}
+
+void StaleHostResolver::SetDnsClientEnabled(bool enabled) {
+  inner_resolver_->SetDnsClientEnabled(enabled);
+}
+
+net::HostCache* StaleHostResolver::GetHostCache() {
+  return inner_resolver_->GetHostCache();
+}
+
+std::unique_ptr<base::Value> StaleHostResolver::GetDnsConfigAsValue() const {
+  return inner_resolver_->GetDnsConfigAsValue();
+}
+
+void StaleHostResolver::OnRequestComplete(StaleHostResolver::Request* request) {
+  DCHECK(request);
+  DCHECK_EQ(1u, pending_requests_.count(request));
+
+  pending_requests_.erase(request);
+  delete request;
+}
+
+}  // namespace net