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"

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,

  // Stale data returned; network got ERR_NAME_NOT_RESOLVED.
  STALE_INSTEAD_OF_NETWORK_NAME_NOT_RESOLVED = 6,

  MAX_REQUEST_OUTCOME
};

void RecordRequestOutcome(RequestOutcome outcome) {
  UMA_HISTOGRAM_ENUMERATION("DNS.StaleHostResolver.RequestOutcome", outcome,
                            MAX_REQUEST_OUTCOME);
}

void RecordCacheSizes(size_t restored, size_t current) {
  UMA_HISTOGRAM_COUNTS_1000("DNS.StaleHostResolver.RestoreSizeOnCacheMiss",
                            restored);
  UMA_HISTOGRAM_COUNTS_1000("DNS.StaleHostResolver.SizeOnCacheMiss", current);
}

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_LONG_TIMES_100("DNS.StaleHostResolver.NetworkEarly",
                                 stale_time - network_time);
  } else {
    UMA_HISTOGRAM_LONG_TIMES_100("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.
class StaleHostResolver::RequestImpl {
 public:
  // If |use_stale_on_name_not_resolved| and network resolution returns
  // ERR_NAME_NOT_RESOLVED, use stale result if available.
  explicit RequestImpl(const base::TickClock* tick_clock,
                       bool use_stale_on_name_not_resolved);
  ~RequestImpl();

  // 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 (unless destroyed first).
  //
  // |addresses| must remain valid until the Request completes (synchronously or
  // via |result_callback|) or is canceled by destroying the Request.
  int Start(net::HostResolverImpl* resolver,
            const RequestInfo& info,
            net::RequestPriority priority,
            net::AddressList* addresses,
            net::CompletionOnceCallback result_callback,
            std::unique_ptr<net::HostResolver::Request>* out_req,
            const net::NetLogWithSource& net_log,
            const StaleEntryUsableCallback& usable_callback,
            base::TimeDelta stale_delay);

  void ChangeRequestPriority(net::RequestPriority priority);

 private:
  class Handle : public net::HostResolver::Request {
   public:
    Handle(RequestImpl* request) : request_(request) {}
    ~Handle() override { request_->OnHandleDestroyed(); }

    void ChangeRequestPriority(net::RequestPriority priority) override {
      request_->ChangeRequestPriority(priority);
    }

   private:
    RequestImpl* request_;
  };

  bool have_network_request() const { return network_request_ != nullptr; }
  bool have_stale_data() const {
    return stale_error_ != net::ERR_DNS_CACHE_MISS;
  }
  bool have_returned() const { return result_callback_.is_null(); }
  bool have_handle() const { return handle_ != nullptr; }

  // 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);
  void OnHandleDestroyed();

  // Fills |*result_addresses_| if rv is OK and returns rv.
  int HandleResult(int rv, const net::AddressList& addresses);
  // Fills |*result_addresses_| if rv is OK and calls |result_callback_| with
  // rv.
  void ReturnResult(int rv, const net::AddressList& addresses);

  void MaybeDeleteThis();

  void RecordSynchronousRequest();
  void RecordNetworkRequest(
      int error,
      bool returned_stale_data,
      bool returned_stale_data_instead_of_network_name_not_resolved);
  void RecordCanceledRequest();

  // The address list passed into |Start()| to be filled in when the request
  // returns.
  net::AddressList* result_addresses_;
  // The callback passed into |Start()| to be called when the request returns.
  net::CompletionOnceCallback result_callback_;
  // Set when |result_callback_| is being called so |OnHandleDestroyed()|
  // doesn't delete the request.
  bool returning_result_;

  // The error from the stale cache entry, if there was one.
  // If not, net::ERR_DNS_CACHE_MISS.
  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_;
  // Shared instance of tick clock, overridden for testing.
  const base::TickClock* tick_clock_;

  // 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 underlying network request, so the priority can be changed.
  std::unique_ptr<net::HostResolver::Request> network_request_;

  // Statistics used in histograms:
  // Number of HostCache entries that were restored from prefs, recorded at the
  // time the cache was checked.
  size_t restore_size_;
  // Current HostCache size at the time the cache was checked.
  size_t current_size_;

  // Handle that caller can use to cancel the request before it returns.
  // Owned by the caller; cleared via |OnHandleDestroyed()| when destroyed.
  Handle* handle_;

  // If |use_stale_on_name_not_resolved| and network resolution returns
  // ERR_NAME_NOT_RESOLVED, use stale result if available.
  const bool use_stale_on_name_not_resolved_;
};

StaleHostResolver::RequestImpl::RequestImpl(const base::TickClock* tick_clock,
                                            bool use_stale_on_name_not_resolved)
    : result_addresses_(nullptr),
      returning_result_(false),
      stale_error_(net::ERR_DNS_CACHE_MISS),
      stale_timer_(tick_clock),
      tick_clock_(tick_clock),
      restore_size_(0),
      current_size_(0),
      handle_(nullptr),
      use_stale_on_name_not_resolved_(use_stale_on_name_not_resolved) {}

StaleHostResolver::RequestImpl::~RequestImpl() {}

int StaleHostResolver::RequestImpl::Start(
    net::HostResolverImpl* resolver,
    const RequestInfo& info,
    net::RequestPriority priority,
    net::AddressList* addresses,
    net::CompletionOnceCallback result_callback,
    std::unique_ptr<net::HostResolver::Request>* out_req,
    const net::NetLogWithSource& net_log,
    const StaleEntryUsableCallback& usable_callback,
    base::TimeDelta stale_delay) {
  DCHECK(resolver);
  DCHECK(addresses);
  DCHECK(!result_callback.is_null());
  DCHECK(out_req);
  DCHECK(!usable_callback.is_null());

  result_addresses_ = addresses;
  restore_size_ = resolver->LastRestoredCacheSize();
  current_size_ = resolver->CacheSize();

  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()) {
    RecordSynchronousRequest();
    return HandleResult(cache_rv, cache_addresses);
  }

  result_callback_ = std::move(result_callback);
  handle_ = new Handle(this);
  *out_req = std::unique_ptr<net::HostResolver::Request>(handle_);

  if (cache_rv == net::OK && 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::RequestImpl::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::BindOnce(&StaleHostResolver::RequestImpl::OnNetworkRequestComplete,
                     base::Unretained(this)),
      &network_request_, net_log);
  // Network resolver has returned synchronously (for example by resolving from
  // /etc/hosts).
  if (network_rv != net::ERR_IO_PENDING) {
    RecordSynchronousRequest();
    return HandleResult(network_rv, network_addresses_);
  }
  return network_rv;
}

void StaleHostResolver::RequestImpl::ChangeRequestPriority(
    net::RequestPriority priority) {
  DCHECK(have_network_request());

  network_request_->ChangeRequestPriority(priority);
}

void StaleHostResolver::RequestImpl::OnStaleDelayElapsed() {
  DCHECK(!have_returned());
  DCHECK(have_stale_data());

  ReturnResult(stale_error_, stale_addresses_);

  // The request needs to wait for both the network request to complete (to
  // backfill the cache) and the caller to delete the handle before deleting
  // itself.
  DCHECK(have_network_request());
}

void StaleHostResolver::RequestImpl::OnNetworkRequestComplete(int error) {
  DCHECK(have_network_request());
  network_request_.reset();

  bool return_stale_data_instead_of_network_name_not_resolved =
      !have_returned() && use_stale_on_name_not_resolved_ &&
      error == net::ERR_NAME_NOT_RESOLVED && have_stale_data();

  RecordNetworkRequest(
      error, /* returned_stale_data = */ have_returned() ||
                 return_stale_data_instead_of_network_name_not_resolved,
      return_stale_data_instead_of_network_name_not_resolved);

  if (!have_returned()) {
    if (have_stale_data())
      stale_timer_.Stop();
    if (return_stale_data_instead_of_network_name_not_resolved) {
      ReturnResult(stale_error_, stale_addresses_);
    } else {
      ReturnResult(error, network_addresses_);
    }
  }

  if (!have_handle())
    delete this;
}

void StaleHostResolver::RequestImpl::OnHandleDestroyed() {
  DCHECK(have_handle());
  handle_ = nullptr;

  // If the caller deletes the handle *before* the request has returned, treat
  // it as a cancel.
  if (!have_returned()) {
    network_request_.reset();
    result_callback_ = net::CompletionOnceCallback();
    RecordCanceledRequest();
  }

  if (!returning_result_ && !have_handle() && !have_network_request())
    delete this;
}

int StaleHostResolver::RequestImpl::HandleResult(
    int rv,
    const net::AddressList& addresses) {
  DCHECK(result_addresses_);

  if (rv == net::OK)
    *result_addresses_ = addresses;
  result_addresses_ = nullptr;
  return rv;
}

void StaleHostResolver::RequestImpl::ReturnResult(
    int rv,
    const net::AddressList& addresses) {
  DCHECK(result_callback_);
  returning_result_ = true;
  std::move(result_callback_).Run(HandleResult(rv, addresses));
  returning_result_ = false;
}

void StaleHostResolver::RequestImpl::RecordSynchronousRequest() {
  RecordRequestOutcome(SYNCHRONOUS);
}

void StaleHostResolver::RequestImpl::RecordNetworkRequest(
    int error,
    bool returned_stale_data,
    bool returned_stale_data_instead_of_network_name_not_resolved) {
  if (have_stale_data())
    RecordTimeDelta(tick_clock_->NowTicks(), stale_timer_.desired_run_time());

  if (returned_stale_data && stale_error_ == net::OK && error == net::OK) {
    RecordAddressListDelta(
        FindAddressListDeltaType(stale_addresses_, network_addresses_));
  }

  if (returned_stale_data) {
    if (returned_stale_data_instead_of_network_name_not_resolved) {
      RecordRequestOutcome(STALE_INSTEAD_OF_NETWORK_NAME_NOT_RESOLVED);
    } else {
      RecordRequestOutcome(STALE_BEFORE_NETWORK);
    }
  } else if (have_stale_data()) {
    RecordRequestOutcome(NETWORK_WITH_STALE);
    RecordCacheSizes(restore_size_, current_size_);
  } else {
    RecordRequestOutcome(NETWORK_WITHOUT_STALE);
  }
}

void StaleHostResolver::RequestImpl::RecordCanceledRequest() {
  if (have_stale_data())
    RecordRequestOutcome(CANCELED_WITH_STALE);
  else
    RecordRequestOutcome(CANCELED_WITHOUT_STALE);
}

StaleHostResolver::StaleOptions::StaleOptions()
    : allow_other_network(false),
      max_stale_uses(0),
      use_stale_on_name_not_resolved(false) {}

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() {}

std::unique_ptr<net::HostResolver::ResolveHostRequest>
StaleHostResolver::CreateRequest(
    const net::HostPortPair& host,
    const net::NetLogWithSource& net_log,
    const base::Optional<ResolveHostParameters>& optional_parameters) {
  // TODO(crbug.com/821021): Implement.
  NOTIMPLEMENTED();
  return nullptr;
}

int StaleHostResolver::Resolve(const RequestInfo& info,
                               net::RequestPriority priority,
                               net::AddressList* addresses,
                               net::CompletionOnceCallback callback,
                               std::unique_ptr<Request>* out_req,
                               const net::NetLogWithSource& net_log) {
  DCHECK(tick_clock_);
  StaleHostResolver::RequestImpl::StaleEntryUsableCallback usable_callback =
      base::Bind(&StaleEntryIsUsable, options_);
  RequestImpl* request =
      new RequestImpl(tick_clock_, options_.use_stale_on_name_not_resolved);
  int rv = request->Start(inner_resolver_.get(), info, priority, addresses,
                          std::move(callback), out_req, net_log,
                          usable_callback, options_.delay);
  if (rv != net::ERR_IO_PENDING)
    delete request;

  return rv;
}

int StaleHostResolver::ResolveFromCache(const RequestInfo& info,
                                        net::AddressList* addresses,
                                        const net::NetLogWithSource& net_log) {
  return inner_resolver_->ResolveFromCache(info, addresses, net_log);
}

int StaleHostResolver::ResolveStaleFromCache(
    const RequestInfo& info,
    net::AddressList* addresses,
    net::HostCache::EntryStaleness* stale_info,
    const net::NetLogWithSource& net_log) {
  return inner_resolver_->ResolveStaleFromCache(info, addresses, stale_info,
                                                net_log);
}

bool StaleHostResolver::HasCached(
    base::StringPiece hostname,
    net::HostCache::Entry::Source* source_out,
    net::HostCache::EntryStaleness* stale_out) const {
  return inner_resolver_->HasCached(hostname, source_out, stale_out);
}

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::SetTickClockForTesting(
    const base::TickClock* tick_clock) {
  tick_clock_ = tick_clock;
  inner_resolver_->SetTickClockForTesting(tick_clock);
}

}  // namespace net