Cronet: Use stale DNS cache entries experimentally.

components/cronet/stale_host_resolver.cc

+// 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 the timer to return stale data.
+  void OnStaleDelayElapsed();
+
+  // Callback for the underlying network request.
+  void OnNetworkRequestComplete(int error);
+
+  // Populates |*addresses_| from |addresses| if and only if rv is OK, clears

[Julia Tuttle, 2016/06/20 13:49:57]

I simplified a few of these comments to avoid just repeating the code
line-for-line in English.

+  // |addresses_| to make sure the request doesn't return twice, and then
+  // returns |rv|.
+  int HandleResult(int rv, const net::AddressList& addresses);
+
+  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_;

[Bryan McQuade, 2016/06/16 16:37:19]

similar - should we set this to a sane default?

[Julia Tuttle, 2016/06/20 13:49:57]

Sure, I'll use net::ERR_DNS_CACHE_MISS as a sentinel for it being unset, and
also reset it to that after returning the stale result.

+  // 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), network_handle_(nullptr) {}
+
+StaleHostResolver::Request::~Request() {
+  if (network_request_running())
+    resolver_->CancelRequest(network_handle_);
+}
+
+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());
+
+  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;
+  addresses_ = addresses;
+  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);

[Bryan McQuade, 2016/06/16 16:37:19]

what happens if stale_delay is the default value (zero)? should we
DCHECK(!stale_delay.is_zero()); at the beginning of this function?

[Julia Tuttle, 2016/06/20 13:49:57]

Zero should Just Work(TM) -- the timer will post a non-delayed task to run
OnStaleDelayElapsed, which will return the stale results shortly after Start was
called.

I'd like to support this use case, since it's effectively the DNS version of
stale-while-revalidate.

If you want, I can do the extra work to make this return synchronously, but I
don't think it's worth the effort.

[Bryan McQuade, 2016/06/20 13:51:47]

Sounds fine as is, thanks!

+  }
+
+  // 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_callback_.Run();
+}
+
+void StaleHostResolver::Request::OnStaleDelayElapsed() {
+  DCHECK(network_request_running());
+  DCHECK(!returned_stale_result());
+
+  base::ResetAndReturn(&result_callback_)
+      .Run(HandleResult(stale_error_, stale_addresses_));
+
+  // Don't call |complete_callback_| yet; let the underlying network request
+  // continue so it backfills the host cache.
+}
+
+void StaleHostResolver::Request::OnNetworkRequestComplete(int error) {
+  DCHECK(network_request_running());
+
+  network_handle_ = nullptr;
+
+  if (!returned_stale_result())
+    result_callback_.Run(HandleResult(error, network_addresses_));
+
+  RecordNetworkRequest(error);
+  complete_callback_.Run();
+}
+
+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::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::StaleHostResolver(
+    std::unique_ptr<net::HostResolverImpl> inner_resolver,
+    const StaleOptions& stale_options)
+    : inner_resolver_(std::move(inner_resolver)), options_(stale_options) {
+  DCHECK_GE(0, stale_options.max_expired_time.InMicroseconds());
+  DCHECK_GE(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());
+
+  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