Pass ResolveContext instead of URLRequestContext

Host resolution will soon use per-context result tracking for the DoH
activation probes.  ContextHostResolver now owns a ResolveContext that
gets passed around in place of raw URLRequestContext to everywhere that
will need access to per-context data (probe results, DoH server
availability, server stats, etc).

Minor behavior change because JobKey now contains ResolveContext. This
means that requests from two different ContextHostResolvers will never
be merged into the same job, even if both are given the same
URLRequestContext. This shouldn't make a difference in practice because
we only create ContextHostResolvers 1:1 with URLRequestsContexts.

Bug: 1022059
Change-Id: Ia9b7bd4d1055630dbfdab627429638bb5f63eb8b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2002899
Commit-Queue: Eric Orth <ericorth@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#737509}

net/dns/context_host_resolver.cc

@@ -18,6 +18,7 @@
 #include "net/dns/host_resolver_manager.h"
 #include "net/dns/host_resolver_proc.h"
 #include "net/dns/public/resolve_error_info.h"
+#include "net/dns/resolve_context.h"
 #include "net/url_request/url_request_context.h"
 
 namespace net {
@@ -246,7 +247,10 @@ class ContextHostResolver::WrappedProbeRequest
 
 ContextHostResolver::ContextHostResolver(HostResolverManager* manager,
                                          std::unique_ptr<HostCache> host_cache)
-    : manager_(manager), host_cache_(std::move(host_cache)) {
+    : manager_(manager),
+      resolve_context_(
+          std::make_unique<ResolveContext>(nullptr /* url_request_context */)),
+      host_cache_(std::move(host_cache)) {
   DCHECK(manager_);
 
   if (host_cache_)
@@ -258,6 +262,8 @@ ContextHostResolver::ContextHostResolver(
     std::unique_ptr<HostCache> host_cache)
     : manager_(owned_manager.get()),
       owned_manager_(std::move(owned_manager)),
+      resolve_context_(
+          std::make_unique<ResolveContext>(nullptr /* url_request_context */)),
       host_cache_(std::move(host_cache)) {
   DCHECK(manager_);
 
@@ -283,9 +289,10 @@ void ContextHostResolver::OnShutdown() {
   for (auto* active_request : handed_out_requests_)
     active_request->OnShutdown();
 
-  DCHECK(context_);
+  DCHECK(resolve_context_);
+  DCHECK(!shutting_down_);
 
-  context_ = nullptr;
+  resolve_context_.reset();
   shutting_down_ = true;
 }
 
@@ -300,9 +307,9 @@ ContextHostResolver::CreateRequest(
   std::unique_ptr<HostResolverManager::CancellableResolveHostRequest>
       inner_request;
   if (!shutting_down_) {
-    inner_request = manager_->CreateRequest(host, network_isolation_key,
-                                            source_net_log, optional_parameters,
-                                            context_, host_cache_.get());
+    inner_request = manager_->CreateRequest(
+        host, network_isolation_key, source_net_log, optional_parameters,
+        resolve_context_.get(), host_cache_.get());
   }
 
   auto request = std::make_unique<WrappedResolveHostRequest>(
@@ -317,7 +324,7 @@ ContextHostResolver::CreateDohProbeRequest() {
 
   std::unique_ptr<HostResolverManager::CancellableProbeRequest> inner_request;
   if (!shutting_down_) {
-    inner_request = manager_->CreateDohProbeRequest(context_);
+    inner_request = manager_->CreateDohProbeRequest(resolve_context_.get());
   }
 
   auto request = std::make_unique<WrappedProbeRequest>(std::move(inner_request),
@@ -342,12 +349,12 @@ std::unique_ptr<base::Value> ContextHostResolver::GetDnsConfigAsValue() const {
 
 void ContextHostResolver::SetRequestContext(
     URLRequestContext* request_context) {
-  DCHECK(request_context);
-  DCHECK(!context_);
+  DCHECK(handed_out_requests_.empty());
   DCHECK(!shutting_down_);
+  DCHECK(!resolve_context_->url_request_context());
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  context_ = request_context;
+  resolve_context_ = std::make_unique<ResolveContext>(request_context);
 }
 
 HostResolverManager* ContextHostResolver::GetManagerForTesting() {
@@ -355,7 +362,7 @@ HostResolverManager* ContextHostResolver::GetManagerForTesting() {
 }
 
 const URLRequestContext* ContextHostResolver::GetContextForTesting() const {
-  return context_;
+  return resolve_context_ ? resolve_context_->url_request_context() : nullptr;
 }
 
 size_t ContextHostResolver::LastRestoredCacheSize() const {

net/dns/context_host_resolver.h

@@ -23,6 +23,7 @@ namespace net {
 class HostCache;
 class HostResolverManager;
 struct ProcTaskParams;
+class ResolveContext;
 class URLRequestContext;
 
 // Wrapper for HostResolverManager, expected to be owned by a URLRequestContext,
@@ -87,7 +88,7 @@ class NET_EXPORT ContextHostResolver : public HostResolver {
   // on resolver destruction.
   std::unordered_set<WrappedRequest*> handed_out_requests_;
 
-  URLRequestContext* context_ = nullptr;
+  std::unique_ptr<ResolveContext> resolve_context_;
   std::unique_ptr<HostCache> host_cache_;
 
   // If true, the context is shutting down. Subsequent request Start() calls

net/dns/context_host_resolver_unittest.cc

@@ -231,57 +231,6 @@ TEST_F(ContextHostResolverTest, DestroyResolver) {
   EXPECT_FALSE(callback1.have_result());
 }
 
-// Test that cancelling a resolver cancels its (and only its) requests, even if
-// those requests shared a job (same query) with another resolver's requests.
-TEST_F(ContextHostResolverTest, DestroyResolver_RemainingRequests) {
-  // Set up delayed results for "example.com".
-  MockDnsClientRuleList rules;
-  rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
-                     MockDnsClientRule::Result(BuildTestDnsResponse(
-                         "example.com", kEndpoint.address())),
-                     true /* delay */);
-  rules.emplace_back("example.com", dns_protocol::kTypeAAAA, false /* secure */,
-                     MockDnsClientRule::Result(MockDnsClientRule::EMPTY),
-                     false /* delay */);
-  SetMockDnsRules(std::move(rules));
-
-  // Make ResolveHostRequests the same hostname for both resolvers.
-  auto resolver1 = std::make_unique<ContextHostResolver>(
-      manager_.get(), nullptr /* host_cache */);
-  std::unique_ptr<HostResolver::ResolveHostRequest> request1 =
-      resolver1->CreateRequest(HostPortPair("example.com", 100),
-                               NetworkIsolationKey(), NetLogWithSource(),
-                               base::nullopt);
-  auto resolver2 = std::make_unique<ContextHostResolver>(
-      manager_.get(), nullptr /* host_cache */);
-  std::unique_ptr<HostResolver::ResolveHostRequest> request2 =
-      resolver2->CreateRequest(HostPortPair("example.com", 100),
-                               NetworkIsolationKey(), NetLogWithSource(),
-                               base::nullopt);
-
-  TestCompletionCallback callback1;
-  int rv1 = request1->Start(callback1.callback());
-  TestCompletionCallback callback2;
-  int rv2 = request2->Start(callback2.callback());
-
-  // Test relies on assumption that requests share jobs, so assert just 1.
-  ASSERT_EQ(1u, manager_->num_jobs_for_testing());
-
-  // Cancel |resolver1| before allowing delayed requests to complete.
-  resolver1 = nullptr;
-  dns_client_->CompleteDelayedTransactions();
-
-  EXPECT_THAT(callback2.GetResult(rv2), test::IsOk());
-  EXPECT_THAT(request2->GetResolveErrorInfo().error, test::IsError(net::OK));
-  EXPECT_THAT(request2->GetAddressResults().value().endpoints(),
-              testing::ElementsAre(kEndpoint));
-
-  // Ensure |request1| never completes.
-  base::RunLoop().RunUntilIdle();
-  EXPECT_THAT(rv1, test::IsError(ERR_IO_PENDING));
-  EXPECT_FALSE(callback1.have_result());
-}
-
 TEST_F(ContextHostResolverTest, DestroyResolver_CompletedRequests) {
   MockDnsClientRuleList rules;
   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,

net/dns/dns_client.cc

@@ -16,6 +16,7 @@
 #include "net/dns/dns_socket_pool.h"
 #include "net/dns/dns_transaction.h"
 #include "net/dns/dns_util.h"
+#include "net/dns/resolve_context.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_event_type.h"
 #include "net/socket/client_socket_factory.h"
@@ -109,7 +110,8 @@ class DnsClientImpl : public DnsClient,
     insecure_enabled_ = enabled;
   }
 
-  bool FallbackFromSecureTransactionPreferred() const override {
+  bool FallbackFromSecureTransactionPreferred(
+      ResolveContext* context) const override {
     if (!CanUseSecureDnsTransactions())
       return true;
 

net/dns/dns_client.h

@@ -14,7 +14,6 @@
 #include "net/dns/dns_config.h"
 #include "net/dns/dns_config_overrides.h"
 #include "net/dns/dns_hosts.h"
-#include "net/url_request/url_request_context.h"
 
 namespace net {
 
@@ -22,6 +21,7 @@ class AddressSorter;
 class ClientSocketFactory;
 class DnsTransactionFactory;
 class NetLog;
+class ResolveContext;
 
 // Entry point for HostResolverManager to interact with the built-in async
 // resolver, as implemented by DnsTransactionFactory. Manages configuration and
@@ -45,7 +45,8 @@ class NET_EXPORT DnsClient {
 
   // When true, DoH should not be used in AUTOMATIC mode since no DoH servers
   // have a successful probe state.
-  virtual bool FallbackFromSecureTransactionPreferred() const = 0;
+  virtual bool FallbackFromSecureTransactionPreferred(
+      ResolveContext* context) const = 0;
 
   // When true, insecure DNS transactions should not be used when reasonable
   // fallback alternatives, e.g. system resolution can be used instead.

net/dns/dns_client_unittest.cc

@@ -13,8 +13,10 @@
 #include "net/base/ip_endpoint.h"
 #include "net/dns/dns_config.h"
 #include "net/dns/dns_test_util.h"
+#include "net/dns/resolve_context.h"
 #include "net/socket/socket_test_util.h"
 #include "net/test/test_with_task_environment.h"
+#include "net/url_request/url_request_context.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -64,6 +66,8 @@ class DnsClientTest : public TestWithTaskEnvironment {
     return config;
   }
 
+  URLRequestContext request_context_;
+  ResolveContext resolve_context_{&request_context_};
   std::unique_ptr<DnsClient> client_;
   AlwaysFailSocketFactory socket_factory_;
 };
@@ -72,7 +76,8 @@ TEST_F(DnsClientTest, NoConfig) {
   client_->SetInsecureEnabled(true);
 
   EXPECT_FALSE(client_->CanUseSecureDnsTransactions());
-  EXPECT_TRUE(client_->FallbackFromSecureTransactionPreferred());
+  EXPECT_TRUE(
+      client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
   EXPECT_FALSE(client_->CanUseInsecureDnsTransactions());
   EXPECT_TRUE(client_->FallbackFromInsecureTransactionPreferred());
 
@@ -86,7 +91,8 @@ TEST_F(DnsClientTest, InvalidConfig) {
   client_->SetSystemConfig(DnsConfig());
 
   EXPECT_FALSE(client_->CanUseSecureDnsTransactions());
-  EXPECT_TRUE(client_->FallbackFromSecureTransactionPreferred());
+  EXPECT_TRUE(
+      client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
   EXPECT_FALSE(client_->CanUseInsecureDnsTransactions());
   EXPECT_TRUE(client_->FallbackFromInsecureTransactionPreferred());
 
@@ -100,7 +106,8 @@ TEST_F(DnsClientTest, CanUseSecureDnsTransactions_NoDohServers) {
   client_->SetSystemConfig(BasicValidConfig());
 
   EXPECT_FALSE(client_->CanUseSecureDnsTransactions());
-  EXPECT_TRUE(client_->FallbackFromSecureTransactionPreferred());
+  EXPECT_TRUE(
+      client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
   EXPECT_TRUE(client_->CanUseInsecureDnsTransactions());
   EXPECT_FALSE(client_->FallbackFromInsecureTransactionPreferred());
 
@@ -115,7 +122,8 @@ TEST_F(DnsClientTest, InsecureNotEnabled) {
   client_->SetSystemConfig(ValidConfigWithDoh());
 
   EXPECT_TRUE(client_->CanUseSecureDnsTransactions());
-  EXPECT_TRUE(client_->FallbackFromSecureTransactionPreferred());
+  EXPECT_TRUE(
+      client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
   EXPECT_FALSE(client_->CanUseInsecureDnsTransactions());
   EXPECT_TRUE(client_->FallbackFromInsecureTransactionPreferred());
 
@@ -128,11 +136,13 @@ TEST_F(DnsClientTest, InsecureNotEnabled) {
 TEST_F(DnsClientTest, CanUseSecureDnsTransactions_ProbeSuccess) {
   client_->SetSystemConfig(ValidConfigWithDoh());
   EXPECT_TRUE(client_->CanUseSecureDnsTransactions());
-  EXPECT_TRUE(client_->FallbackFromSecureTransactionPreferred());
+  EXPECT_TRUE(
+      client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
 
   client_->SetProbeSuccessForTest(0, true /* success */);
   EXPECT_TRUE(client_->CanUseSecureDnsTransactions());
-  EXPECT_FALSE(client_->FallbackFromSecureTransactionPreferred());
+  EXPECT_FALSE(
+      client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
 }
 
 TEST_F(DnsClientTest, DnsOverTlsActive) {
@@ -142,7 +152,8 @@ TEST_F(DnsClientTest, DnsOverTlsActive) {
   client_->SetSystemConfig(config);
 
   EXPECT_TRUE(client_->CanUseSecureDnsTransactions());
-  EXPECT_TRUE(client_->FallbackFromSecureTransactionPreferred());
+  EXPECT_TRUE(
+      client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
   EXPECT_FALSE(client_->CanUseInsecureDnsTransactions());
   EXPECT_TRUE(client_->FallbackFromInsecureTransactionPreferred());
 
@@ -157,7 +168,8 @@ TEST_F(DnsClientTest, AllAllowed) {
   client_->SetProbeSuccessForTest(0, true /* success */);
 
   EXPECT_TRUE(client_->CanUseSecureDnsTransactions());
-  EXPECT_FALSE(client_->FallbackFromSecureTransactionPreferred());
+  EXPECT_FALSE(
+      client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
   EXPECT_TRUE(client_->CanUseInsecureDnsTransactions());
   EXPECT_FALSE(client_->FallbackFromInsecureTransactionPreferred());
 
@@ -173,7 +185,8 @@ TEST_F(DnsClientTest, FallbackFromInsecureTransactionPreferred_Failures) {
 
   for (int i = 0; i < DnsClient::kMaxInsecureFallbackFailures; ++i) {
     EXPECT_TRUE(client_->CanUseSecureDnsTransactions());
-    EXPECT_TRUE(client_->FallbackFromSecureTransactionPreferred());
+    EXPECT_TRUE(
+        client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
     EXPECT_TRUE(client_->CanUseInsecureDnsTransactions());
     EXPECT_FALSE(client_->FallbackFromInsecureTransactionPreferred());
 
@@ -181,14 +194,16 @@ TEST_F(DnsClientTest, FallbackFromInsecureTransactionPreferred_Failures) {
   }
 
   EXPECT_TRUE(client_->CanUseSecureDnsTransactions());
-  EXPECT_TRUE(client_->FallbackFromSecureTransactionPreferred());
+  EXPECT_TRUE(
+      client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
   EXPECT_TRUE(client_->CanUseInsecureDnsTransactions());
   EXPECT_TRUE(client_->FallbackFromInsecureTransactionPreferred());
 
   client_->ClearInsecureFallbackFailures();
 
   EXPECT_TRUE(client_->CanUseSecureDnsTransactions());
-  EXPECT_TRUE(client_->FallbackFromSecureTransactionPreferred());
+  EXPECT_TRUE(
+      client_->FallbackFromSecureTransactionPreferred(&resolve_context_));
   EXPECT_TRUE(client_->CanUseInsecureDnsTransactions());
   EXPECT_FALSE(client_->FallbackFromInsecureTransactionPreferred());
 }

net/dns/dns_test_util.cc

@@ -18,6 +18,7 @@
 #include "net/dns/dns_hosts.h"
 #include "net/dns/dns_query.h"
 #include "net/dns/dns_util.h"
+#include "net/dns/resolve_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -613,18 +614,18 @@ std::unique_ptr<DnsTransaction> MockDnsTransactionFactory::CreateTransaction(
     const NetLogWithSource&,
     bool secure,
     DnsConfig::SecureDnsMode secure_dns_mode,
-    URLRequestContext* url_request_context) {
+    ResolveContext* resolve_context) {
   std::unique_ptr<MockTransaction> transaction =
-      std::make_unique<MockTransaction>(rules_, hostname, qtype, secure,
-                                        secure_dns_mode, url_request_context,
-                                        std::move(callback));
+      std::make_unique<MockTransaction>(
+          rules_, hostname, qtype, secure, secure_dns_mode,
+          resolve_context->url_request_context(), std::move(callback));
   if (transaction->delayed())
     delayed_transactions_.push_back(transaction->AsWeakPtr());
   return transaction;
 }
 
 std::unique_ptr<DnsProbeRunner> MockDnsTransactionFactory::CreateDohProbeRunner(
-    URLRequestContext* url_request_context) {
+    ResolveContext* resolve_context) {
   return std::make_unique<MockDohProbeRunner>(weak_ptr_factory_.GetWeakPtr());
 }
 
@@ -680,7 +681,8 @@ void MockDnsClient::SetInsecureEnabled(bool enabled) {
   insecure_enabled_ = enabled;
 }
 
-bool MockDnsClient::FallbackFromSecureTransactionPreferred() const {
+bool MockDnsClient::FallbackFromSecureTransactionPreferred(
+    ResolveContext* context) const {
   return !CanUseSecureDnsTransactions() || !doh_server_available_;
 }
 

net/dns/dns_test_util.h

@@ -22,6 +22,7 @@
 #include "net/dns/dns_response.h"
 #include "net/dns/dns_transaction.h"
 #include "net/dns/dns_util.h"
+#include "net/dns/esni_content.h"
 #include "net/dns/public/dns_protocol.h"
 
 namespace net {
@@ -200,6 +201,7 @@ std::string GenerateWellFormedEsniKeys(base::StringPiece custom_data = "");
 class AddressSorter;
 class DnsClient;
 class IPAddress;
+class ResolveContext;
 class URLRequestContext;
 
 // Builds an address record for the given name and IP.
@@ -300,10 +302,10 @@ class MockDnsTransactionFactory : public DnsTransactionFactory {
       const NetLogWithSource&,
       bool secure,
       DnsConfig::SecureDnsMode secure_dns_mode,
-      URLRequestContext* url_request_context) override;
+      ResolveContext* resolve_context) override;
 
   std::unique_ptr<DnsProbeRunner> CreateDohProbeRunner(
-      URLRequestContext* url_request_context) override;
+      ResolveContext* resolve_context) override;
 
   void AddEDNSOption(const OptRecordRdata::Opt& opt) override;
 
@@ -340,7 +342,8 @@ class MockDnsClient : public DnsClient {
   bool CanUseSecureDnsTransactions() const override;
   bool CanUseInsecureDnsTransactions() const override;
   void SetInsecureEnabled(bool enabled) override;
-  bool FallbackFromSecureTransactionPreferred() const override;
+  bool FallbackFromSecureTransactionPreferred(
+      ResolveContext* resolve_context) const override;
   bool FallbackFromInsecureTransactionPreferred() const override;
   bool SetSystemConfig(base::Optional<DnsConfig> system_config) override;
   bool SetConfigOverrides(DnsConfigOverrides config_overrides) override;

net/dns/dns_transaction.cc

@@ -48,6 +48,7 @@
 #include "net/dns/dns_session.h"
 #include "net/dns/dns_util.h"
 #include "net/dns/public/dns_protocol.h"
+#include "net/dns/resolve_context.h"
 #include "net/http/http_request_headers.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_capture_mode.h"
@@ -854,10 +855,9 @@ const net::BackoffEntry::Policy kProbeBackoffPolicy = {
 class DnsOverHttpsProbeRunner : public DnsProbeRunner {
  public:
   DnsOverHttpsProbeRunner(base::WeakPtr<DnsSession> session,
-                          URLRequestContext* context)
+                          ResolveContext* context)
       : session_(std::move(session)), context_(context) {
     DCHECK(session_);
-    DCHECK(context_);
     DCHECK(!session_->config().dns_over_https_servers.empty());
 
     DNSDomainFromDot(kDoHProbeHostname, &formatted_probe_hostname_);
@@ -946,11 +946,11 @@ class DnsOverHttpsProbeRunner : public DnsProbeRunner {
         probe_stats->backoff_entry->GetTimeUntilRelease());
 
     unsigned attempt_number = probe_stats->probe_attempts.size();
-    ConstructDnsHTTPAttempt(session_.get(), doh_server_index,
-                            formatted_probe_hostname_, dns_protocol::kTypeA,
-                            nullptr /* opt_rdata */,
-                            &probe_stats->probe_attempts, context_,
-                            RequestPriority::DEFAULT_PRIORITY);
+    ConstructDnsHTTPAttempt(
+        session_.get(), doh_server_index, formatted_probe_hostname_,
+        dns_protocol::kTypeA, nullptr /* opt_rdata */,
+        &probe_stats->probe_attempts, context_->url_request_context(),
+        RequestPriority::DEFAULT_PRIORITY);
 
     probe_stats->probe_attempts.back()->Start(base::BindOnce(
         &DnsOverHttpsProbeRunner::ProbeComplete, weak_ptr_factory_.GetWeakPtr(),
@@ -1001,7 +1001,8 @@ class DnsOverHttpsProbeRunner : public DnsProbeRunner {
 
   bool started_ = false;
   base::WeakPtr<DnsSession> session_;
-  URLRequestContext* const context_;
+  // TODO(ericorth@chromium.org): Use base::UnownedPtr once available.
+  ResolveContext* const context_;
   std::string formatted_probe_hostname_;
 
   // List of ProbeStats, one for each DoH server, indexed by the DoH server
@@ -1030,7 +1031,7 @@ class DnsTransactionImpl : public DnsTransaction,
                      const OptRecordRdata* opt_rdata,
                      bool secure,
                      DnsConfig::SecureDnsMode secure_dns_mode,
-                     URLRequestContext* url_request_context)
+                     ResolveContext* resolve_context)
       : session_(session),
         hostname_(hostname),
         qtype_(qtype),
@@ -1044,7 +1045,7 @@ class DnsTransactionImpl : public DnsTransaction,
         doh_attempts_(0),
         had_tcp_attempt_(false),
         first_server_index_(0),
-        url_request_context_(url_request_context),
+        resolve_context_(resolve_context),
         request_priority_(DEFAULT_PRIORITY) {
     DCHECK(session_.get());
     DCHECK(!hostname_.empty());
@@ -1236,7 +1237,6 @@ class DnsTransactionImpl : public DnsTransaction,
 
   AttemptResult MakeHTTPAttempt() {
     DCHECK(secure_);
-    DCHECK(url_request_context_);
 
     // doh_attempts_ counts the number of attempts made via HTTPS. To
     // get a server index cap that by the number of DoH servers we
@@ -1250,9 +1250,9 @@ class DnsTransactionImpl : public DnsTransaction,
       return AttemptResult(ERR_BLOCKED_BY_CLIENT, nullptr);
 
     unsigned attempt_number = attempts_.size();
-    ConstructDnsHTTPAttempt(session_.get(), doh_server_index, qnames_.front(),
-                            qtype_, opt_rdata_, &attempts_,
-                            url_request_context_, request_priority_);
+    ConstructDnsHTTPAttempt(
+        session_.get(), doh_server_index, qnames_.front(), qtype_, opt_rdata_,
+        &attempts_, resolve_context_->url_request_context(), request_priority_);
     ++doh_attempts_;
     ++attempts_count_;
     int rv = attempts_.back()->Start(base::BindOnce(
@@ -1480,7 +1480,8 @@ class DnsTransactionImpl : public DnsTransaction,
 
   base::OneShotTimer timer_;
 
-  URLRequestContext* url_request_context_;
+  // TODO(ericorth@chromium.org): Use base::UnownedPtr once available.
+  ResolveContext* resolve_context_;
   RequestPriority request_priority_;
 
   THREAD_CHECKER(thread_checker_);
@@ -1505,16 +1506,16 @@ class DnsTransactionFactoryImpl : public DnsTransactionFactory {
       const NetLogWithSource& net_log,
       bool secure,
       DnsConfig::SecureDnsMode secure_dns_mode,
-      URLRequestContext* url_request_context) override {
+      ResolveContext* resolve_context) override {
     return std::make_unique<DnsTransactionImpl>(
         session_.get(), hostname, qtype, std::move(callback), net_log,
-        opt_rdata_.get(), secure, secure_dns_mode, url_request_context);
+        opt_rdata_.get(), secure, secure_dns_mode, resolve_context);
   }
 
   std::unique_ptr<DnsProbeRunner> CreateDohProbeRunner(
-      URLRequestContext* url_request_context) override {
+      ResolveContext* resolve_context) override {
     return std::make_unique<DnsOverHttpsProbeRunner>(session_->GetWeakPtr(),
-                                                     url_request_context);
+                                                     resolve_context);
   }
 
   void AddEDNSOption(const OptRecordRdata::Opt& opt) override {

net/dns/dns_transaction.h

@@ -23,7 +23,7 @@ namespace net {
 class DnsResponse;
 class DnsSession;
 class NetLogWithSource;
-class URLRequestContext;
+class ResolveContext;
 
 // DnsTransaction implements a stub DNS resolver as defined in RFC 1034.
 // The DnsTransaction takes care of retransmissions, name server fallback (or
@@ -106,12 +106,12 @@ class NET_EXPORT_PRIVATE DnsTransactionFactory {
       const NetLogWithSource& net_log,
       bool secure,
       DnsConfig::SecureDnsMode secure_dns_mode,
-      URLRequestContext* url_request_context) WARN_UNUSED_RESULT = 0;
+      ResolveContext* resolve_context) WARN_UNUSED_RESULT = 0;
 
   // Creates a runner to run the DoH probe sequence for all configured DoH
   // resolvers.
   virtual std::unique_ptr<DnsProbeRunner> CreateDohProbeRunner(
-      URLRequestContext* url_request_context) WARN_UNUSED_RESULT = 0;
+      ResolveContext* resolve_context) WARN_UNUSED_RESULT = 0;
 
   // The given EDNS0 option will be included in all DNS queries performed by
   // transactions from this factory.

net/dns/host_resolver_manager.h

@@ -50,7 +50,7 @@ class MDnsSocketFactory;
 class NetLog;
 class NetLogWithSource;
 class NetworkIsolationKey;
-class URLRequestContext;
+class ResolveContext;
 
 // Scheduler and controller of host resolution requests. Because of the global
 // nature of host resolutions, this class is generally expected to be singleton
@@ -142,19 +142,19 @@ class NET_EXPORT HostResolverManager
   // If |host_cache| is non-null, its HostCache::Invalidator must have already
   // been added (via AddHostCacheInvalidator()). If |optional_parameters|
   // specifies any cache usage other than LOCAL_ONLY, there must be a 1:1
-  // correspondence between |request_context| and |host_cache|, and both should
+  // correspondence between |resolve_context| and |host_cache|, and both should
   // come from the same ContextHostResolver.
   std::unique_ptr<CancellableResolveHostRequest> CreateRequest(
       const HostPortPair& host,
       const NetworkIsolationKey& network_isolation_key,
       const NetLogWithSource& net_log,
       const base::Optional<ResolveHostParameters>& optional_parameters,
-      URLRequestContext* request_context,
+      ResolveContext* resolve_context,
       HostCache* host_cache);
-  // |request_context| is the context to use for the probes, and it is expected
+  // |resolve_context| is the context to use for the probes, and it is expected
   // to be the context of the calling ContextHostResolver.
   std::unique_ptr<CancellableProbeRequest> CreateDohProbeRequest(
-      URLRequestContext* request_context);
+      ResolveContext* resolvet_context);
   std::unique_ptr<MdnsListener> CreateMdnsListener(const HostPortPair& host,
                                                    DnsQueryType query_type);
 
@@ -289,6 +289,7 @@ class NET_EXPORT HostResolverManager
       ResolveHostParameters::CacheUsage cache_usage,
       const NetLogWithSource& request_net_log,
       HostCache* cache,
+      ResolveContext* resolve_context,
       DnsQueryType* out_effective_query_type,
       HostResolverFlags* out_effective_host_resolver_flags,
       DnsConfig::SecureDnsMode* out_effective_secure_dns_mode,
@@ -356,6 +357,7 @@ class NET_EXPORT HostResolverManager
                     bool insecure_tasks_allowed,
                     bool allow_cache,
                     bool prioritize_local_lookups,
+                    ResolveContext* resolve_context,
                     std::deque<TaskType>* out_tasks);
 
   // Initialized the sequence of tasks to run to resolve a request. The sequence
@@ -367,6 +369,7 @@ class NET_EXPORT HostResolverManager
       HostResolverFlags flags,
       base::Optional<SecureDnsMode> secure_dns_mode_override,
       ResolveHostParameters::CacheUsage cache_usage,
+      ResolveContext* resolve_context,
       DnsConfig::SecureDnsMode* out_effective_secure_dns_mode,
       std::deque<TaskType>* out_tasks);
 
@@ -381,6 +384,7 @@ class NET_EXPORT HostResolverManager
       ResolveHostParameters::CacheUsage cache_usage,
       const IPAddress* ip_address,
       const NetLogWithSource& net_log,
+      ResolveContext* resolve_context,
       DnsQueryType* out_effective_type,
       HostResolverFlags* out_effective_flags,
       DnsConfig::SecureDnsMode* out_effective_secure_dns_mode,
@@ -456,7 +460,7 @@ class NET_EXPORT HostResolverManager
   // Returns |nullptr| if DoH probes are currently not allowed (due to
   // configuration or current connection state).
   std::unique_ptr<DnsProbeRunner> CreateDohProbeRunner(
-      URLRequestContext* url_request_context);
+      ResolveContext* resolve_context);
 
   // Used for multicast DNS tasks. Created on first use using
   // GetOrCreateMndsClient().

net/dns/resolve_context.cc

@@ -12,9 +12,7 @@
 namespace net {
 
 ResolveContext::ResolveContext(URLRequestContext* url_request_context)
-    : url_request_context_(url_request_context) {
-  DCHECK(url_request_context_);
-}
+    : url_request_context_(url_request_context) {}
 
 ResolveContext::~ResolveContext() = default;