Reland "Create ResolveContext"

Fix a missing nullptr initialization.

Original change:
https://chromium-review.googlesource.com/c/chromium/src/+/2003256

Change-Id: I5aa663c8273449c0e77f526c55097eb288edb72d
Bug: 1047641, 1022059
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2032787
Commit-Queue: Eric Orth <ericorth@chromium.org>
Commit-Queue: Matt Menke <mmenke@chromium.org>
Auto-Submit: Eric Orth <ericorth@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Reviewed-by: Eric Orth <ericorth@chromium.org>
Cr-Commit-Position: refs/heads/master@{#737446}

net/dns/BUILD.gn

@@ -75,6 +75,8 @@ source_set("dns") {
       "notify_watcher_mac.h",
       "record_parsed.cc",
       "record_rdata.cc",
+      "resolve_context.cc",
+      "resolve_context.h",
       "serial_worker.cc",
       "serial_worker.h",
       "system_dns_config_change_notifier.cc",
@@ -387,6 +389,7 @@ source_set("tests") {
     "mapped_host_resolver_unittest.cc",
     "record_parsed_unittest.cc",
     "record_rdata_unittest.cc",
+    "resolve_context_unittest.cc",
     "serial_worker_unittest.cc",
     "system_dns_config_change_notifier_unittest.cc",
   ]

net/dns/dns_session.cc

@@ -241,6 +241,15 @@ unsigned DnsSession::NumAvailableDohServers() {
   return count;
 }
 
+base::Time DnsSession::GetLastDohFailure(size_t server_index) {
+  return GetServerStats(server_index, true /* is_doh_server */)->last_failure;
+}
+
+int DnsSession::GetLastDohFailureCount(size_t server_index) {
+  return GetServerStats(server_index, true /* is_doh_server */)
+      ->last_failure_count;
+}
+
 DnsSession::ServerStats* DnsSession::GetServerStats(unsigned server_index,
                                                     bool is_doh_server) {
   DCHECK_GE(server_index, 0u);

net/dns/dns_session.h

@@ -102,6 +102,10 @@ class NET_EXPORT_PRIVATE DnsSession : public base::RefCounted<DnsSession> {
   // Returns the number of DoH servers with successful probe states.
   unsigned NumAvailableDohServers();
 
+  // TODO(b/1022059): Remove once all server stats are moved to ResolveContext.
+  base::Time GetLastDohFailure(size_t server_index);
+  int GetLastDohFailureCount(size_t server_index);
+
   // Record that server failed to respond (due to SRV_FAIL or timeout). If
   // |is_doh_server| and the number of failures has surpassed a threshold,
   // sets the DoH probe state to unavailable.
@@ -173,6 +177,9 @@ class NET_EXPORT_PRIVATE DnsSession : public base::RefCounted<DnsSession> {
   base::TimeDelta initial_timeout_;
   base::TimeDelta max_timeout_;
 
+  // TODO(crbug.com/1022059): Move all handling of ServerStats (both for DoH and
+  // non-DoH) to ResolveContext.
+
   // Track runtime statistics of each insecure DNS server.
   std::vector<std::unique_ptr<ServerStats>> server_stats_;
 

net/dns/resolve_context.cc

+// Copyright 2020 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 "net/dns/resolve_context.h"
+
+#include "base/logging.h"
+#include "base/time/time.h"
+#include "net/base/network_change_notifier.h"
+#include "net/dns/dns_session.h"
+
+namespace net {
+
+ResolveContext::ResolveContext(URLRequestContext* url_request_context)
+    : url_request_context_(url_request_context) {
+  DCHECK(url_request_context_);
+}
+
+ResolveContext::~ResolveContext() = default;
+
+void ResolveContext::SetCurrentSession(DnsSession* session) {
+  DCHECK(!IsCurrentSession(session));
+
+  current_session_ = session;
+
+  doh_server_availability_.clear();
+  if (session) {
+    doh_server_availability_.insert(
+        doh_server_availability_.begin(),
+        session->config().dns_over_https_servers.size(), false);
+  }
+}
+
+base::Optional<size_t> ResolveContext::DohServerIndexToUse(
+    size_t starting_doh_server_index,
+    DnsConfig::SecureDnsMode secure_dns_mode,
+    const DnsSession* session) {
+  if (!IsCurrentSession(session))
+    return base::nullopt;
+
+  DCHECK_LT(starting_doh_server_index,
+            session->config().dns_over_https_servers.size());
+  size_t index = starting_doh_server_index;
+  base::Time oldest_server_failure;
+  base::Optional<size_t> oldest_available_server_failure_index;
+
+  do {
+    // For a server to be considered "available", the server must have a
+    // successful probe status if we are in AUTOMATIC mode.
+    if (secure_dns_mode == DnsConfig::SecureDnsMode::SECURE ||
+        doh_server_availability_[index]) {
+      // If number of failures on this server doesn't exceed |config_.attempts|,
+      // return its index. |config_.attempts| will generally be more restrictive
+      // than |kAutomaticModeFailureLimit|, although this is not guaranteed.
+      if (current_session_->GetLastDohFailureCount(index) <
+          session->config().attempts) {
+        return index;
+      }
+      // Track oldest failed available server.
+      base::Time cur_server_failure =
+          current_session_->GetLastDohFailure(index);
+      if (!oldest_available_server_failure_index ||
+          cur_server_failure < oldest_server_failure) {
+        oldest_server_failure = cur_server_failure;
+        oldest_available_server_failure_index = index;
+      }
+    }
+    index = (index + 1) % session->config().dns_over_https_servers.size();
+  } while (index != starting_doh_server_index);
+
+  // If we are here it means that there are either no available DoH servers or
+  // that all available DoH servers have at least |config_.attempts| consecutive
+  // failures. In the latter case, we'll return the available DoH server that
+  // failed least recently. In the former case we return nullopt.
+  return oldest_available_server_failure_index;
+}
+
+size_t ResolveContext::NumAvailableDohServers(const DnsSession* session) const {
+  if (!IsCurrentSession(session))
+    return 0;
+
+  size_t count = 0;
+  for (const auto& probe_result : doh_server_availability_) {
+    if (probe_result)
+      count++;
+  }
+  return count;
+}
+
+bool ResolveContext::GetDohServerAvailability(size_t doh_server_index,
+                                              const DnsSession* session) const {
+  if (!IsCurrentSession(session))
+    return false;
+
+  DCHECK_LT(doh_server_index, doh_server_availability_.size());
+
+  return doh_server_availability_[doh_server_index];
+}
+
+void ResolveContext::SetProbeSuccess(size_t doh_server_index,
+                                     bool success,
+                                     const DnsSession* session) {
+  if (!IsCurrentSession(session))
+    return;
+
+  DCHECK_LT(doh_server_index, session->config().dns_over_https_servers.size());
+
+  bool doh_available_before = NumAvailableDohServers(session) > 0;
+  doh_server_availability_[doh_server_index] = success;
+
+  // TODO(crbug.com/1022059): Consider figuring out some way to only for the
+  // first context enabling DoH or the last context disabling DoH.
+  if (doh_available_before != NumAvailableDohServers(session) > 0)
+    NetworkChangeNotifier::TriggerNonSystemDnsChange();
+}
+
+bool ResolveContext::IsCurrentSession(const DnsSession* session) const {
+  DCHECK(session);
+  return session == current_session_;
+}
+
+}  // namespace net

net/dns/resolve_context.h

+// Copyright 2020 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 NET_DNS_RESOLVE_CONTEXT_H_
+#define NET_DNS_RESOLVE_CONTEXT_H_
+
+#include <vector>
+
+#include "base/optional.h"
+#include "net/base/net_export.h"
+#include "net/dns/dns_config.h"
+
+namespace net {
+
+class DnsSession;
+class URLRequestContext;
+
+// Per-URLRequestContext data used by HostResolver. Expected to be owned by the
+// ContextHostResolver, and all usage/references are expected to be cleaned up
+// or cancelled before the URLRequestContext goes out of service.
+class NET_EXPORT_PRIVATE ResolveContext {
+ public:
+  explicit ResolveContext(URLRequestContext* url_request_context);
+
+  ResolveContext(const ResolveContext&) = delete;
+  ResolveContext& operator=(const ResolveContext&) = delete;
+
+  ~ResolveContext();
+
+  // Sets the "current" session for this ResolveContext and clears all session-
+  // specific properties.
+  void SetCurrentSession(DnsSession* current_session);
+
+  // Find the index of a DoH server to use for this attempt. Starts from
+  // |starting_doh_server_index| and finds the first eligible server (wrapping
+  // around as necessary) below failure limits, or of no eligible servers are
+  // below failure limits, the one with the oldest last failure. If in AUTOMATIC
+  // mode, a server is only eligible after a successful DoH probe. Returns
+  // nullopt if there are no eligible DoH servers or |session| is not the
+  // current session.
+  base::Optional<size_t> DohServerIndexToUse(
+      size_t starting_doh_server_index,
+      DnsConfig::SecureDnsMode secure_dns_mode,
+      const DnsSession* session);
+
+  // Returns the number of DoH servers with successful probe states. Always 0 if
+  // |session| is not the current session.
+  size_t NumAvailableDohServers(const DnsSession* session) const;
+
+  // Returns whether |doh_server_index| is marked available. Always |false| if
+  // |session| is not the current session.
+  bool GetDohServerAvailability(size_t doh_server_index,
+                                const DnsSession* session) const;
+
+  // Record the latest DoH probe state. Noop if |session| is not the current
+  // session.
+  void SetProbeSuccess(size_t doh_server_index,
+                       bool success,
+                       const DnsSession* session);
+
+  URLRequestContext* url_request_context() { return url_request_context_; }
+
+ private:
+  bool IsCurrentSession(const DnsSession* session) const;
+
+  URLRequestContext* url_request_context_;
+
+  // Per-session data is only stored and valid for the latest session. Before
+  // accessing, should check that |current_session_| is valid and matches a
+  // passed in DnsSession.
+  //
+  // TODO(crbug.com/1022059): Make const DnsSession once server stats have been
+  // moved and no longer need to be read from DnsSession for availability logic.
+  DnsSession* current_session_ = nullptr;
+  std::vector<bool> doh_server_availability_;
+};
+
+}  // namespace net
+
+#endif  // NET_DNS_RESOLVE_CONTEXT_H_