Add NetworkIsolationKey argument to HostResolver::CreateRequest.

Nothing populates it yet, other than a test this CL adds.


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

components/cronet/stale_host_resolver.cc

@@ -17,6 +17,7 @@
 #include "base/values.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
+#include "net/base/network_isolation_key.h"
 #include "net/dns/context_host_resolver.h"
 #include "net/dns/dns_util.h"
 #include "net/dns/host_resolver_source.h"
@@ -91,6 +92,7 @@ class StaleHostResolver::RequestImpl
   // StaleOptions will be read directly from |resolver|.
   RequestImpl(base::WeakPtr<StaleHostResolver> resolver,
               const net::HostPortPair& host,
+              const net::NetworkIsolationKey& network_isolation_key,
               const net::NetLogWithSource& net_log,
               const ResolveHostParameters& input_parameters,
               const base::TickClock* tick_clock);
@@ -143,6 +145,7 @@ class StaleHostResolver::RequestImpl
   base::WeakPtr<StaleHostResolver> resolver_;
 
   const net::HostPortPair host_;
+  const net::NetworkIsolationKey network_isolation_key_;
   const net::NetLogWithSource net_log_;
   const ResolveHostParameters input_parameters_;
 
@@ -176,11 +179,13 @@ class StaleHostResolver::RequestImpl
 StaleHostResolver::RequestImpl::RequestImpl(
     base::WeakPtr<StaleHostResolver> resolver,
     const net::HostPortPair& host,
+    const net::NetworkIsolationKey& network_isolation_key,
     const net::NetLogWithSource& net_log,
     const ResolveHostParameters& input_parameters,
     const base::TickClock* tick_clock)
     : resolver_(std::move(resolver)),
       host_(host),
+      network_isolation_key_(network_isolation_key),
       net_log_(net_log),
       input_parameters_(input_parameters),
       cache_error_(net::ERR_DNS_CACHE_MISS),
@@ -207,8 +212,8 @@ int StaleHostResolver::RequestImpl::Start(
   cache_parameters.cache_usage =
       net::HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
   cache_parameters.source = net::HostResolverSource::LOCAL_ONLY;
-  cache_request_ = resolver_->inner_resolver_->CreateRequest(host_, net_log_,
-                                                             cache_parameters);
+  cache_request_ = resolver_->inner_resolver_->CreateRequest(
+      host_, network_isolation_key_, net_log_, cache_parameters);
   cache_error_ =
       cache_request_->Start(base::BindOnce([](int error) { NOTREACHED(); }));
   DCHECK_NE(net::ERR_IO_PENDING, cache_error_);
@@ -247,7 +252,7 @@ int StaleHostResolver::RequestImpl::Start(
   no_cache_parameters.cache_usage =
       net::HostResolver::ResolveHostParameters::CacheUsage::DISALLOWED;
   network_request_ = resolver_->inner_resolver_->CreateRequest(
-      host_, net_log_, no_cache_parameters);
+      host_, network_isolation_key_, net_log_, no_cache_parameters);
   int network_rv = network_request_->Start(
       base::BindOnce(&StaleHostResolver::OnNetworkRequestComplete, resolver_,
                      network_request_.get(), weak_ptr_factory_.GetWeakPtr()));
@@ -458,11 +463,12 @@ void StaleHostResolver::OnShutdown() {
 std::unique_ptr<net::HostResolver::ResolveHostRequest>
 StaleHostResolver::CreateRequest(
     const net::HostPortPair& host,
+    const net::NetworkIsolationKey& network_isolation_key,
     const net::NetLogWithSource& net_log,
     const base::Optional<ResolveHostParameters>& optional_parameters) {
   DCHECK(tick_clock_);
   return std::make_unique<RequestImpl>(
-      weak_ptr_factory_.GetWeakPtr(), host, net_log,
+      weak_ptr_factory_.GetWeakPtr(), host, network_isolation_key, net_log,
       optional_parameters.value_or(ResolveHostParameters()), tick_clock_);
 }
 

components/cronet/stale_host_resolver.h

@@ -80,6 +80,7 @@ class StaleHostResolver : public net::HostResolver {
   // request to continue in order to repopulate the cache.
   std::unique_ptr<ResolveHostRequest> CreateRequest(
       const net::HostPortPair& host,
+      const net::NetworkIsolationKey& network_isolation_key,
       const net::NetLogWithSource& net_log,
       const base::Optional<ResolveHostParameters>& optional_parameters)
       override;

net/dns/context_host_resolver.cc

@@ -208,14 +208,14 @@ void ContextHostResolver::OnShutdown() {
 std::unique_ptr<HostResolver::ResolveHostRequest>
 ContextHostResolver::CreateRequest(
     const HostPortPair& host,
+    const NetworkIsolationKey& network_isolation_key,
     const NetLogWithSource& source_net_log,
     const base::Optional<ResolveHostParameters>& optional_parameters) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   std::unique_ptr<HostResolverManager::CancellableRequest> inner_request;
   if (!shutting_down_) {
-    // TODO(mmenke): Pass in a NetworkIsolationKey.
-    inner_request = manager_->CreateRequest(host, NetworkIsolationKey(),
+    inner_request = manager_->CreateRequest(host, network_isolation_key,
                                             source_net_log, optional_parameters,
                                             context_, host_cache_.get());
   }

net/dns/context_host_resolver.h

@@ -46,6 +46,7 @@ class NET_EXPORT ContextHostResolver : public HostResolver {
   void OnShutdown() override;
   std::unique_ptr<ResolveHostRequest> CreateRequest(
       const HostPortPair& host,
+      const NetworkIsolationKey& network_isolation_key,
       const NetLogWithSource& net_log,
       const base::Optional<ResolveHostParameters>& optional_parameters)
       override;

net/dns/host_resolver.cc

@@ -99,6 +99,14 @@ HostResolver::ResolveHostParameters::ResolveHostParameters(
 
 HostResolver::~HostResolver() = default;
 
+std::unique_ptr<HostResolver::ResolveHostRequest> HostResolver::CreateRequest(
+    const HostPortPair& host,
+    const NetLogWithSource& net_log,
+    const base::Optional<ResolveHostParameters>& optional_parameters) {
+  return CreateRequest(host, NetworkIsolationKey(), net_log,
+                       optional_parameters);
+}
+
 std::unique_ptr<HostResolver::MdnsListener> HostResolver::CreateMdnsListener(
     const HostPortPair& host,
     DnsQueryType query_type) {

net/dns/host_resolver.h

@@ -290,9 +290,19 @@ class NET_EXPORT HostResolver {
   // defaults will be used if passed |base::nullopt|.
   virtual std::unique_ptr<ResolveHostRequest> CreateRequest(
       const HostPortPair& host,
+      const NetworkIsolationKey& network_isolation_key,
       const NetLogWithSource& net_log,
       const base::Optional<ResolveHostParameters>& optional_parameters) = 0;
 
+  // Deprecated version of above method that uses an empty NetworkIsolationKey.
+  //
+  // TODO(mmenke): Once all consumers have been updated to use the other
+  // overload instead, remove this method and make above method pure virtual.
+  virtual std::unique_ptr<ResolveHostRequest> CreateRequest(
+      const HostPortPair& host,
+      const NetLogWithSource& net_log,
+      const base::Optional<ResolveHostParameters>& optional_parameters);
+
   // Create a listener to watch for updates to an MDNS result.
   virtual std::unique_ptr<MdnsListener> CreateMdnsListener(
       const HostPortPair& host,

net/dns/mapped_host_resolver.cc

@@ -26,6 +26,7 @@ void MappedHostResolver::OnShutdown() {
 std::unique_ptr<HostResolver::ResolveHostRequest>
 MappedHostResolver::CreateRequest(
     const HostPortPair& host,
+    const NetworkIsolationKey& network_isolation_key,
     const NetLogWithSource& source_net_log,
     const base::Optional<ResolveHostParameters>& optional_parameters) {
   HostPortPair rewritten = host;
@@ -34,7 +35,8 @@ MappedHostResolver::CreateRequest(
   if (rewritten.host() == "~NOTFOUND")
     return CreateFailingRequest(ERR_NAME_NOT_RESOLVED);
 
-  return impl_->CreateRequest(rewritten, source_net_log, optional_parameters);
+  return impl_->CreateRequest(rewritten, network_isolation_key, source_net_log,
+                              optional_parameters);
 }
 
 HostCache* MappedHostResolver::GetHostCache() {

net/dns/mapped_host_resolver.h

@@ -52,6 +52,7 @@ class NET_EXPORT MappedHostResolver : public HostResolver {
   // HostResolver methods:
   std::unique_ptr<ResolveHostRequest> CreateRequest(
       const HostPortPair& host,
+      const NetworkIsolationKey& network_isolation_key,
       const NetLogWithSource& net_log,
       const base::Optional<ResolveHostParameters>& optional_parameters)
       override;

net/dns/mapped_host_resolver_unittest.cc

@@ -48,7 +48,8 @@ TEST(MappedHostResolverTest, Inclusion) {
   TestCompletionCallback callback;
   std::unique_ptr<HostResolver::ResolveHostRequest> request =
       resolver->CreateRequest(HostPortPair("www.google.com", 80),
-                              NetLogWithSource(), base::nullopt);
+                              NetworkIsolationKey(), NetLogWithSource(),
+                              base::nullopt);
   int rv = request->Start(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
@@ -61,7 +62,8 @@ TEST(MappedHostResolverTest, Inclusion) {
 
   // Try resolving "www.google.com:80". Should be remapped to "baz.com:80".
   request = resolver->CreateRequest(HostPortPair("www.google.com", 80),
-                                    NetLogWithSource(), base::nullopt);
+                                    NetworkIsolationKey(), NetLogWithSource(),
+                                    base::nullopt);
   rv = request->Start(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
@@ -73,7 +75,8 @@ TEST(MappedHostResolverTest, Inclusion) {
   // Try resolving "foo.com:77". This will NOT be remapped, so result
   // is "foo.com:77".
   request = resolver->CreateRequest(HostPortPair("foo.com", 77),
-                                    NetLogWithSource(), base::nullopt);
+                                    NetworkIsolationKey(), NetLogWithSource(),
+                                    base::nullopt);
   rv = request->Start(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
@@ -87,7 +90,8 @@ TEST(MappedHostResolverTest, Inclusion) {
 
   // Try resolving "chromium.org:61". Should be remapped to "proxy:99".
   request = resolver->CreateRequest(HostPortPair("chromium.org", 61),
-                                    NetLogWithSource(), base::nullopt);
+                                    NetworkIsolationKey(), NetLogWithSource(),
+                                    base::nullopt);
   rv = request->Start(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
@@ -120,7 +124,8 @@ TEST(MappedHostResolverTest, Exclusion) {
   // Try resolving "www.google.com". Should not be remapped due to exclusion).
   std::unique_ptr<HostResolver::ResolveHostRequest> request =
       resolver->CreateRequest(HostPortPair("www.google.com", 80),
-                              NetLogWithSource(), base::nullopt);
+                              NetworkIsolationKey(), NetLogWithSource(),
+                              base::nullopt);
   int rv = request->Start(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
@@ -131,7 +136,8 @@ TEST(MappedHostResolverTest, Exclusion) {
 
   // Try resolving "chrome.com:80". Should be remapped to "baz:80".
   request = resolver->CreateRequest(HostPortPair("chrome.com", 80),
-                                    NetLogWithSource(), base::nullopt);
+                                    NetworkIsolationKey(), NetLogWithSource(),
+                                    base::nullopt);
   rv = request->Start(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
@@ -160,7 +166,8 @@ TEST(MappedHostResolverTest, SetRulesFromString) {
   // Try resolving "www.google.com". Should be remapped to "baz".
   std::unique_ptr<HostResolver::ResolveHostRequest> request =
       resolver->CreateRequest(HostPortPair("www.google.com", 80),
-                              NetLogWithSource(), base::nullopt);
+                              NetworkIsolationKey(), NetLogWithSource(),
+                              base::nullopt);
   int rv = request->Start(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
@@ -171,7 +178,8 @@ TEST(MappedHostResolverTest, SetRulesFromString) {
 
   // Try resolving "chrome.net:80". Should be remapped to "bar:60".
   request = resolver->CreateRequest(HostPortPair("chrome.net", 80),
-                                    NetLogWithSource(), base::nullopt);
+                                    NetworkIsolationKey(), NetLogWithSource(),
+                                    base::nullopt);
   rv = request->Start(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
@@ -215,7 +223,8 @@ TEST(MappedHostResolverTest, MapToError) {
   TestCompletionCallback callback1;
   std::unique_ptr<HostResolver::ResolveHostRequest> request =
       resolver->CreateRequest(HostPortPair("www.google.com", 80),
-                              NetLogWithSource(), base::nullopt);
+                              NetworkIsolationKey(), NetLogWithSource(),
+                              base::nullopt);
   int rv = request->Start(callback1.callback());
   EXPECT_THAT(rv, IsError(ERR_NAME_NOT_RESOLVED));
   request.reset();
@@ -223,7 +232,8 @@ TEST(MappedHostResolverTest, MapToError) {
   // Try resolving www.foo.com --> Should succeed.
   TestCompletionCallback callback2;
   request = resolver->CreateRequest(HostPortPair("www.foo.com", 80),
-                                    NetLogWithSource(), base::nullopt);
+                                    NetworkIsolationKey(), NetLogWithSource(),
+                                    base::nullopt);
   rv = request->Start(callback2.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback2.WaitForResult();

net/dns/mock_host_resolver.cc

@@ -303,6 +303,7 @@ void MockHostResolverBase::OnShutdown() {
 std::unique_ptr<HostResolver::ResolveHostRequest>
 MockHostResolverBase::CreateRequest(
     const HostPortPair& host,
+    const NetworkIsolationKey& network_isolation_key,
     const NetLogWithSource& source_net_log,
     const base::Optional<ResolveHostParameters>& optional_parameters) {
   return std::make_unique<RequestImpl>(host, optional_parameters, AsWeakPtr());
@@ -954,6 +955,7 @@ void HangingHostResolver::OnShutdown() {
 std::unique_ptr<HostResolver::ResolveHostRequest>
 HangingHostResolver::CreateRequest(
     const HostPortPair& host,
+    const NetworkIsolationKey& network_isolation_key,
     const NetLogWithSource& source_net_log,
     const base::Optional<ResolveHostParameters>& optional_parameters) {
   if (shutting_down_)

net/dns/mock_host_resolver.h

@@ -116,6 +116,7 @@ class MockHostResolverBase
   void OnShutdown() override;
   std::unique_ptr<ResolveHostRequest> CreateRequest(
       const HostPortPair& host,
+      const NetworkIsolationKey& network_isolation_key,
       const NetLogWithSource& net_log,
       const base::Optional<ResolveHostParameters>& optional_parameters)
       override;
@@ -160,6 +161,9 @@ class MockHostResolverBase
   // Returns the priority of the request with the given id.
   RequestPriority request_priority(size_t id);
 
+  // Returns NetworkIsolationKey of the request with the given id.
+  const NetworkIsolationKey& network_isolation_key(size_t id);
+
   // Like ResolveNow, but doesn't take an ID. DCHECKs if there's more than one
   // pending request.
   void ResolveOnlyRequestNow();
@@ -451,6 +455,7 @@ class HangingHostResolver : public HostResolver {
   void OnShutdown() override;
   std::unique_ptr<ResolveHostRequest> CreateRequest(
       const HostPortPair& host,
+      const NetworkIsolationKey& network_isolation_key,
       const NetLogWithSource& net_log,
       const base::Optional<ResolveHostParameters>& optional_parameters)
       override;