NetworkIsolationKeys + PAC scripts PS3: HostResolverMojo

Make HostResolverMojo take a NetworkIsolationKey. It now both passes the
NetworkIsolationKey to the HostResolverMojo::Impl it wraps, and uses the
NetworkIsolationKey as part of the key into its local HostCache.

Bug: 1021661
Change-Id: Ib9fc433635933c0e0a587c762d4ce6e581bf7317
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1904487
Commit-Queue: Matt Menke <mmenke@chromium.org>
Reviewed-by: Eric Roman <eroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#714978}

net/proxy_resolution/mock_proxy_host_resolver.cc

@@ -61,8 +61,10 @@ MockProxyHostResolver::MockProxyHostResolver(bool synchronous_mode)
 MockProxyHostResolver::~MockProxyHostResolver() = default;
 
 std::unique_ptr<ProxyHostResolver::Request>
-MockProxyHostResolver::CreateRequest(const std::string& hostname,
-                                     ProxyResolveDnsOperation operation) {
+MockProxyHostResolver::CreateRequest(
+    const std::string& hostname,
+    ProxyResolveDnsOperation operation,
+    const net::NetworkIsolationKey& network_isolation_key) {
   ++num_resolve_;
 
   if (fail_all_)
@@ -123,8 +125,10 @@ HangingProxyHostResolver::HangingProxyHostResolver(
 HangingProxyHostResolver::~HangingProxyHostResolver() = default;
 
 std::unique_ptr<ProxyHostResolver::Request>
-HangingProxyHostResolver::CreateRequest(const std::string& hostname,
-                                        ProxyResolveDnsOperation operation) {
+HangingProxyHostResolver::CreateRequest(
+    const std::string& hostname,
+    ProxyResolveDnsOperation operation,
+    const net::NetworkIsolationKey& network_isolation_key) {
   return std::make_unique<RequestImpl>(this);
 }
 

net/proxy_resolution/mock_proxy_host_resolver.h

@@ -30,7 +30,8 @@ class MockProxyHostResolver : public ProxyHostResolver {
 
   std::unique_ptr<Request> CreateRequest(
       const std::string& hostname,
-      ProxyResolveDnsOperation operation) override;
+      ProxyResolveDnsOperation operation,
+      const net::NetworkIsolationKey& network_isolation_key) override;
 
   void SetError(const std::string& hostname,
                 ProxyResolveDnsOperation operation);
@@ -65,7 +66,8 @@ class HangingProxyHostResolver : public ProxyHostResolver {
 
   std::unique_ptr<Request> CreateRequest(
       const std::string& hostname,
-      ProxyResolveDnsOperation operation) override;
+      ProxyResolveDnsOperation operation,
+      const net::NetworkIsolationKey& network_isolation_key) override;
 
   int num_cancelled_requests() const { return num_cancelled_requests_; }
 

net/proxy_resolution/proxy_host_resolver.h

@@ -15,6 +15,8 @@
 
 namespace net {
 
+class NetworkIsolationKey;
+
 // Interface for a limited (compared to the standard HostResolver) host resolver
 // used just for proxy resolution.
 class NET_EXPORT ProxyHostResolver {
@@ -30,7 +32,8 @@ class NET_EXPORT ProxyHostResolver {
 
   virtual std::unique_ptr<Request> CreateRequest(
       const std::string& hostname,
-      ProxyResolveDnsOperation operation) = 0;
+      ProxyResolveDnsOperation operation,
+      const net::NetworkIsolationKey& network_isolation_key) = 0;
 };
 
 }  // namespace net

net/proxy_resolution/proxy_resolver_v8_tracing.cc

@@ -24,6 +24,7 @@
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
+#include "net/base/network_isolation_key.h"
 #include "net/base/trace_constants.h"
 #include "net/log/net_log_with_source.h"
 #include "net/proxy_resolution/proxy_host_resolver.h"
@@ -732,8 +733,10 @@ void Job::DoDnsOperation() {
   bool is_myip_request =
       pending_dns_op_ == ProxyResolveDnsOperation::MY_IP_ADDRESS ||
       pending_dns_op_ == ProxyResolveDnsOperation::MY_IP_ADDRESS_EX;
+  // TODO(mmenke): Pass in a NetworkIsolationKey.
   pending_dns_ = host_resolver()->CreateRequest(
-      is_myip_request ? GetHostName() : pending_dns_host_, pending_dns_op_);
+      is_myip_request ? GetHostName() : pending_dns_host_, pending_dns_op_,
+      NetworkIsolationKey());
   int result =
       pending_dns_->Start(base::BindOnce(&Job::OnDnsOperationComplete, this));
 

services/proxy_resolver/host_resolver_mojo.cc

@@ -17,6 +17,7 @@
 #include "net/base/completion_once_callback.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
+#include "net/base/network_isolation_key.h"
 #include "net/dns/host_resolver_source.h"
 #include "net/dns/public/dns_query_type.h"
 
@@ -31,6 +32,7 @@ constexpr auto kNegativeCacheEntryTTL = base::TimeDelta();
 
 net::HostCache::Key CacheKeyForRequest(
     const std::string& hostname,
+    const net::NetworkIsolationKey& network_isolation_key,
     net::ProxyResolveDnsOperation operation) {
   net::DnsQueryType dns_query_type = net::DnsQueryType::UNSPECIFIED;
   if (operation == net::ProxyResolveDnsOperation::MY_IP_ADDRESS ||
@@ -38,9 +40,9 @@ net::HostCache::Key CacheKeyForRequest(
     dns_query_type = net::DnsQueryType::A;
   }
 
-  return net::HostCache::Key(hostname, dns_query_type,
-                             0 /* host_resolver_flags */,
-                             net::HostResolverSource::ANY);
+  return net::HostCache::Key(
+      hostname, dns_query_type, 0 /* host_resolver_flags */,
+      net::HostResolverSource::ANY, network_isolation_key);
 }
 
 }  // namespace
@@ -50,10 +52,12 @@ class HostResolverMojo::RequestImpl : public ProxyHostResolver::Request,
  public:
   RequestImpl(const std::string& hostname,
               net::ProxyResolveDnsOperation operation,
+              const net::NetworkIsolationKey& network_isolation_key,
               base::WeakPtr<net::HostCache> host_cache,
               Impl* impl)
       : hostname_(hostname),
         operation_(operation),
+        network_isolation_key_(network_isolation_key),
         host_cache_(std::move(host_cache)),
         impl_(impl) {}
 
@@ -71,7 +75,7 @@ class HostResolverMojo::RequestImpl : public ProxyHostResolver::Request,
     }
 
     callback_ = std::move(callback);
-    impl_->ResolveDns(hostname_, operation_,
+    impl_->ResolveDns(hostname_, operation_, network_isolation_key_,
                       receiver_.BindNewPipeAndPassRemote());
     receiver_.set_disconnect_handler(
         base::BindOnce(&RequestImpl::OnDisconnect, base::Unretained(this)));
@@ -95,8 +99,9 @@ class HostResolverMojo::RequestImpl : public ProxyHostResolver::Request,
       net::HostCache::Entry entry(
           error, net::AddressList::CreateFromIPAddressList(result, ""),
           net::HostCache::Entry::SOURCE_UNKNOWN, ttl);
-      host_cache_->Set(CacheKeyForRequest(hostname_, operation_), entry,
-                       base::TimeTicks::Now(), ttl);
+      host_cache_->Set(
+          CacheKeyForRequest(hostname_, network_isolation_key_, operation_),
+          entry, base::TimeTicks::Now(), ttl);
     }
     receiver_.reset();
     std::move(callback_).Run(error);
@@ -106,7 +111,8 @@ class HostResolverMojo::RequestImpl : public ProxyHostResolver::Request,
   int ResolveFromCacheInternal() {
     DCHECK(host_cache_);
 
-    net::HostCache::Key key = CacheKeyForRequest(hostname_, operation_);
+    net::HostCache::Key key =
+        CacheKeyForRequest(hostname_, network_isolation_key_, operation_);
     const std::pair<const net::HostCache::Key, net::HostCache::Entry>*
         cache_result = host_cache_->Lookup(key, base::TimeTicks::Now());
     if (!cache_result)
@@ -129,6 +135,7 @@ class HostResolverMojo::RequestImpl : public ProxyHostResolver::Request,
 
   const std::string hostname_;
   const net::ProxyResolveDnsOperation operation_;
+  const net::NetworkIsolationKey network_isolation_key_;
 
   mojo::Receiver<mojom::HostResolverRequestClient> receiver_{this};
   net::CompletionOnceCallback callback_;
@@ -148,11 +155,14 @@ HostResolverMojo::HostResolverMojo(Impl* impl)
 HostResolverMojo::~HostResolverMojo() = default;
 
 std::unique_ptr<net::ProxyHostResolver::Request>
-HostResolverMojo::CreateRequest(const std::string& hostname,
-                                net::ProxyResolveDnsOperation operation) {
+HostResolverMojo::CreateRequest(
+    const std::string& hostname,
+    net::ProxyResolveDnsOperation operation,
+    const net::NetworkIsolationKey& network_isolation_key) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return std::make_unique<RequestImpl>(
-      hostname, operation, host_cache_weak_factory_.GetWeakPtr(), impl_);
+      hostname, operation, network_isolation_key,
+      host_cache_weak_factory_.GetWeakPtr(), impl_);
 }
 
 }  // namespace proxy_resolver

services/proxy_resolver/host_resolver_mojo.h

@@ -16,6 +16,10 @@
 #include "net/proxy_resolution/proxy_resolve_dns_operation.h"
 #include "services/proxy_resolver/public/mojom/proxy_resolver.mojom.h"
 
+namespace net {
+class NetworkIsolationKey;
+}  // namespace net
+
 namespace proxy_resolver {
 
 // A ProxyHostResolver implementation that converts requests to mojo types and
@@ -28,6 +32,7 @@ class HostResolverMojo : public net::ProxyHostResolver {
     virtual void ResolveDns(
         const std::string& hostname,
         net::ProxyResolveDnsOperation operation,
+        const net::NetworkIsolationKey& network_isolation_key,
         mojo::PendingRemote<mojom::HostResolverRequestClient> client) = 0;
   };
 
@@ -38,7 +43,8 @@ class HostResolverMojo : public net::ProxyHostResolver {
   // ProxyHostResolver overrides.
   std::unique_ptr<Request> CreateRequest(
       const std::string& hostname,
-      net::ProxyResolveDnsOperation operation) override;
+      net::ProxyResolveDnsOperation operation,
+      const net::NetworkIsolationKey& network_isolation_key) override;
 
  private:
   class Job;

services/proxy_resolver/mojo_proxy_resolver_v8_tracing_bindings.h

@@ -66,10 +66,10 @@ class MojoProxyResolverV8TracingBindings
   void ResolveDns(
       const std::string& hostname,
       net::ProxyResolveDnsOperation operation,
+      const net::NetworkIsolationKey& network_isolation_key,
       mojo::PendingRemote<mojom::HostResolverRequestClient> client) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    // TODO(mmenke): Pass in a NetworkIsolationKey.
-    client_->ResolveDns(hostname, operation, net::NetworkIsolationKey(),
+    client_->ResolveDns(hostname, operation, network_isolation_key,
                         std::move(client));
   }