xref: /aosp_15_r20/external/cronet/net/dns/context_host_resolver_unittest.cc (revision 6777b5387eb2ff775bb5750e3f5d96f37fb7352b) 
1 // Copyright 2019 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "net/dns/context_host_resolver.h"
6 
7 #include <memory>
8 #include <optional>
9 #include <utility>
10 
11 #include "base/containers/fixed_flat_map.h"
12 #include "base/functional/bind.h"
13 #include "base/memory/raw_ptr.h"
14 #include "base/run_loop.h"
15 #include "base/test/scoped_feature_list.h"
16 #include "base/test/simple_test_tick_clock.h"
17 #include "base/test/task_environment.h"
18 #include "base/time/time.h"
19 #include "net/base/features.h"
20 #include "net/base/host_port_pair.h"
21 #include "net/base/ip_address.h"
22 #include "net/base/ip_endpoint.h"
23 #include "net/base/mock_network_change_notifier.h"
24 #include "net/base/net_errors.h"
25 #include "net/base/network_isolation_key.h"
26 #include "net/base/schemeful_site.h"
27 #include "net/base/test_completion_callback.h"
28 #include "net/dns/dns_config.h"
29 #include "net/dns/dns_test_util.h"
30 #include "net/dns/dns_util.h"
31 #include "net/dns/host_cache.h"
32 #include "net/dns/host_resolver.h"
33 #include "net/dns/host_resolver_manager.h"
34 #include "net/dns/host_resolver_results_test_util.h"
35 #include "net/dns/host_resolver_system_task.h"
36 #include "net/dns/mock_host_resolver.h"
37 #include "net/dns/public/dns_over_https_config.h"
38 #include "net/dns/public/dns_protocol.h"
39 #include "net/dns/public/host_resolver_source.h"
40 #include "net/dns/public/resolve_error_info.h"
41 #include "net/dns/resolve_context.h"
42 #include "net/log/net_log_with_source.h"
43 #include "net/test/gtest_util.h"
44 #include "net/test/test_with_task_environment.h"
45 #include "net/url_request/url_request_context.h"
46 #include "net/url_request/url_request_context_builder.h"
47 #include "net/url_request/url_request_test_util.h"
48 #include "testing/gmock/include/gmock/gmock.h"
49 #include "testing/gtest/include/gtest/gtest.h"
50 #include "url/gurl.h"
51 #include "url/scheme_host_port.h"
52 
53 #if BUILDFLAG(IS_ANDROID)
54 #include "base/android/build_info.h"
55 #include "net/android/network_change_notifier_factory_android.h"
56 #endif  // BUILDFLAG(IS_ANDROID)
57 
58 namespace net {
59 
60 namespace {
61 const IPEndPoint kEndpoint(IPAddress(1, 2, 3, 4), 100);
62 }
63 
64 class ContextHostResolverTest : public ::testing::Test,
65                                 public WithTaskEnvironment {
66  protected:
67   // Use mock time to prevent the HostResolverManager's injected IPv6 probe
68   // result from timing out.
ContextHostResolverTest()69   ContextHostResolverTest()
70       : WithTaskEnvironment(
71             base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
72 
73   ~ContextHostResolverTest() override = default;
74 
SetUp()75   void SetUp() override {
76     manager_ = std::make_unique<HostResolverManager>(
77         HostResolver::ManagerOptions(),
78         nullptr /* system_dns_config_notifier */, nullptr /* net_log */);
79     manager_->SetLastIPv6ProbeResultForTesting(true);
80   }
81 
SetMockDnsRules(MockDnsClientRuleList rules)82   void SetMockDnsRules(MockDnsClientRuleList rules) {
83     IPAddress dns_ip(192, 168, 1, 0);
84     DnsConfig config;
85     config.nameservers.emplace_back(dns_ip, dns_protocol::kDefaultPort);
86     config.doh_config = *DnsOverHttpsConfig::FromString("https://example.com");
87     EXPECT_TRUE(config.IsValid());
88 
89     auto dns_client =
90         std::make_unique<MockDnsClient>(std::move(config), std::move(rules));
91     dns_client->set_ignore_system_config_changes(true);
92     dns_client_ = dns_client.get();
93     manager_->SetDnsClientForTesting(std::move(dns_client));
94     manager_->SetInsecureDnsClientEnabled(
95         /*enabled=*/true,
96         /*additional_dns_types_enabled=*/true);
97 
98     // Ensure DnsClient is fully usable.
99     EXPECT_TRUE(dns_client_->CanUseInsecureDnsTransactions());
100     EXPECT_FALSE(dns_client_->FallbackFromInsecureTransactionPreferred());
101     EXPECT_TRUE(dns_client_->GetEffectiveConfig());
102 
103     scoped_refptr<HostResolverProc> proc = CreateCatchAllHostResolverProc();
104     manager_->set_host_resolver_system_params_for_test(
105         HostResolverSystemTask::Params(proc, 1u));
106   }
107 
108   std::unique_ptr<HostResolverManager> manager_;
109   raw_ptr<MockDnsClient> dns_client_;
110 };
111 
TEST_F(ContextHostResolverTest,Resolve)112 TEST_F(ContextHostResolverTest, Resolve) {
113   auto context = CreateTestURLRequestContextBuilder()->Build();
114 
115   MockDnsClientRuleList rules;
116   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
117                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
118                          "example.com", kEndpoint.address())),
119                      false /* delay */, context.get());
120   rules.emplace_back(
121       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
122       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
123       false /* delay */, context.get());
124   SetMockDnsRules(std::move(rules));
125 
126   auto resolve_context = std::make_unique<ResolveContext>(
127       context.get(), false /* enable_caching */);
128   auto resolver = std::make_unique<ContextHostResolver>(
129       manager_.get(), std::move(resolve_context));
130   std::unique_ptr<HostResolver::ResolveHostRequest> request =
131       resolver->CreateRequest(HostPortPair("example.com", 100),
132                               NetworkAnonymizationKey(), NetLogWithSource(),
133                               std::nullopt);
134 
135   TestCompletionCallback callback;
136   int rv = request->Start(callback.callback());
137   EXPECT_THAT(callback.GetResult(rv), test::IsOk());
138   EXPECT_THAT(request->GetResolveErrorInfo().error, test::IsError(net::OK));
139   EXPECT_THAT(request->GetAddressResults()->endpoints(),
140               testing::ElementsAre(kEndpoint));
141 }
142 
TEST_F(ContextHostResolverTest,ResolveWithScheme)143 TEST_F(ContextHostResolverTest, ResolveWithScheme) {
144   auto context = CreateTestURLRequestContextBuilder()->Build();
145 
146   MockDnsClientRuleList rules;
147   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
148                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
149                          "example.com", kEndpoint.address())),
150                      false /* delay */, context.get());
151   rules.emplace_back(
152       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
153       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
154       false /* delay */, context.get());
155   SetMockDnsRules(std::move(rules));
156 
157   auto resolve_context = std::make_unique<ResolveContext>(
158       context.get(), false /* enable_caching */);
159   auto resolver = std::make_unique<ContextHostResolver>(
160       manager_.get(), std::move(resolve_context));
161   std::unique_ptr<HostResolver::ResolveHostRequest> request =
162       resolver->CreateRequest(
163           url::SchemeHostPort(url::kHttpsScheme, "example.com", 100),
164           NetworkAnonymizationKey(), NetLogWithSource(), std::nullopt);
165 
166   TestCompletionCallback callback;
167   int rv = request->Start(callback.callback());
168   EXPECT_THAT(callback.GetResult(rv), test::IsOk());
169   EXPECT_THAT(request->GetResolveErrorInfo().error, test::IsError(net::OK));
170   EXPECT_THAT(request->GetAddressResults()->endpoints(),
171               testing::ElementsAre(kEndpoint));
172 }
173 
TEST_F(ContextHostResolverTest,ResolveWithSchemeAndIpLiteral)174 TEST_F(ContextHostResolverTest, ResolveWithSchemeAndIpLiteral) {
175   auto context = CreateTestURLRequestContextBuilder()->Build();
176 
177   IPAddress expected_address;
178   ASSERT_TRUE(expected_address.AssignFromIPLiteral("1234::5678"));
179 
180   auto resolve_context = std::make_unique<ResolveContext>(
181       context.get(), false /* enable_caching */);
182   auto resolver = std::make_unique<ContextHostResolver>(
183       manager_.get(), std::move(resolve_context));
184   std::unique_ptr<HostResolver::ResolveHostRequest> request =
185       resolver->CreateRequest(
186           url::SchemeHostPort(url::kHttpsScheme, "[1234::5678]", 100),
187           NetworkAnonymizationKey(), NetLogWithSource(), std::nullopt);
188 
189   TestCompletionCallback callback;
190   int rv = request->Start(callback.callback());
191   EXPECT_THAT(callback.GetResult(rv), test::IsOk());
192   EXPECT_THAT(request->GetResolveErrorInfo().error, test::IsError(net::OK));
193   EXPECT_THAT(request->GetAddressResults()->endpoints(),
194               testing::ElementsAre(IPEndPoint(expected_address, 100)));
195 }
196 
197 // Test that destroying a request silently cancels that request.
TEST_F(ContextHostResolverTest,DestroyRequest)198 TEST_F(ContextHostResolverTest, DestroyRequest) {
199   // Set up delayed results for "example.com".
200   MockDnsClientRuleList rules;
201   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
202                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
203                          "example.com", IPAddress(1, 2, 3, 4))),
204                      true /* delay */);
205   rules.emplace_back(
206       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
207       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
208       false /* delay */);
209   SetMockDnsRules(std::move(rules));
210 
211   auto resolver = std::make_unique<ContextHostResolver>(
212       manager_.get(),
213       std::make_unique<ResolveContext>(nullptr /* url_request_context */,
214                                        false /* enable_caching */));
215   std::unique_ptr<HostResolver::ResolveHostRequest> request =
216       resolver->CreateRequest(HostPortPair("example.com", 100),
217                               NetworkAnonymizationKey(), NetLogWithSource(),
218                               std::nullopt);
219 
220   TestCompletionCallback callback;
221   int rv = request->Start(callback.callback());
222 
223   // Cancel |request| before allowing delayed result to complete.
224   request = nullptr;
225   dns_client_->CompleteDelayedTransactions();
226 
227   // Ensure |request| never completes.
228   base::RunLoop().RunUntilIdle();
229   EXPECT_THAT(rv, test::IsError(ERR_IO_PENDING));
230   EXPECT_FALSE(callback.have_result());
231 }
232 
TEST_F(ContextHostResolverTest,DohProbeRequest)233 TEST_F(ContextHostResolverTest, DohProbeRequest) {
234   // Set empty MockDnsClient rules to ensure DnsClient is mocked out.
235   MockDnsClientRuleList rules;
236   SetMockDnsRules(std::move(rules));
237 
238   auto context = CreateTestURLRequestContextBuilder()->Build();
239   auto resolve_context = std::make_unique<ResolveContext>(
240       context.get(), true /* enable caching */);
241   auto resolver = std::make_unique<ContextHostResolver>(
242       manager_.get(), std::move(resolve_context));
243 
244   std::unique_ptr<HostResolver::ProbeRequest> request =
245       resolver->CreateDohProbeRequest();
246 
247   ASSERT_FALSE(dns_client_->factory()->doh_probes_running());
248 
249   EXPECT_THAT(request->Start(), test::IsError(ERR_IO_PENDING));
250   EXPECT_TRUE(dns_client_->factory()->doh_probes_running());
251 
252   request.reset();
253 
254   EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
255 }
256 
TEST_F(ContextHostResolverTest,DohProbesFromSeparateContexts)257 TEST_F(ContextHostResolverTest, DohProbesFromSeparateContexts) {
258   // Set empty MockDnsClient rules to ensure DnsClient is mocked out.
259   MockDnsClientRuleList rules;
260   SetMockDnsRules(std::move(rules));
261 
262   auto resolve_context1 = std::make_unique<ResolveContext>(
263       nullptr /* url_request_context */, false /* enable_caching */);
264   auto resolver1 = std::make_unique<ContextHostResolver>(
265       manager_.get(), std::move(resolve_context1));
266   std::unique_ptr<HostResolver::ProbeRequest> request1 =
267       resolver1->CreateDohProbeRequest();
268 
269   auto resolve_context2 = std::make_unique<ResolveContext>(
270       nullptr /* url_request_context */, false /* enable_caching */);
271   auto resolver2 = std::make_unique<ContextHostResolver>(
272       manager_.get(), std::move(resolve_context2));
273   std::unique_ptr<HostResolver::ProbeRequest> request2 =
274       resolver2->CreateDohProbeRequest();
275 
276   EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
277 
278   EXPECT_THAT(request1->Start(), test::IsError(ERR_IO_PENDING));
279   EXPECT_THAT(request2->Start(), test::IsError(ERR_IO_PENDING));
280 
281   EXPECT_TRUE(dns_client_->factory()->doh_probes_running());
282 
283   request1.reset();
284 
285   EXPECT_TRUE(dns_client_->factory()->doh_probes_running());
286 
287   request2.reset();
288 
289   EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
290 }
291 
292 // Test that cancelling a resolver cancels its (and only its) requests.
TEST_F(ContextHostResolverTest,DestroyResolver)293 TEST_F(ContextHostResolverTest, DestroyResolver) {
294   // Set up delayed results for "example.com" and "google.com".
295   MockDnsClientRuleList rules;
296   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
297                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
298                          "example.com", IPAddress(2, 3, 4, 5))),
299                      true /* delay */);
300   rules.emplace_back(
301       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
302       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
303       false /* delay */);
304   rules.emplace_back("google.com", dns_protocol::kTypeA, false /* secure */,
305                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
306                          "google.com", kEndpoint.address())),
307                      true /* delay */);
308   rules.emplace_back(
309       "google.com", dns_protocol::kTypeAAAA, false /* secure */,
310       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
311       false /* delay */);
312   SetMockDnsRules(std::move(rules));
313 
314   auto resolver1 = std::make_unique<ContextHostResolver>(
315       manager_.get(),
316       std::make_unique<ResolveContext>(nullptr /* url_request_context */,
317                                        false /* enable_caching */));
318   std::unique_ptr<HostResolver::ResolveHostRequest> request1 =
319       resolver1->CreateRequest(HostPortPair("example.com", 100),
320                                NetworkAnonymizationKey(), NetLogWithSource(),
321                                std::nullopt);
322   auto resolver2 = std::make_unique<ContextHostResolver>(
323       manager_.get(),
324       std::make_unique<ResolveContext>(nullptr /* url_request_context */,
325                                        false /* enable_caching */));
326   std::unique_ptr<HostResolver::ResolveHostRequest> request2 =
327       resolver2->CreateRequest(HostPortPair("google.com", 100),
328                                NetworkAnonymizationKey(), NetLogWithSource(),
329                                std::nullopt);
330 
331   TestCompletionCallback callback1;
332   int rv1 = request1->Start(callback1.callback());
333   TestCompletionCallback callback2;
334   int rv2 = request2->Start(callback2.callback());
335 
336   EXPECT_EQ(2u, manager_->num_jobs_for_testing());
337 
338   // Cancel |resolver1| before allowing delayed requests to complete.
339   resolver1 = nullptr;
340   dns_client_->CompleteDelayedTransactions();
341 
342   EXPECT_THAT(callback2.GetResult(rv2), test::IsOk());
343   EXPECT_THAT(request2->GetAddressResults()->endpoints(),
344               testing::ElementsAre(kEndpoint));
345 
346   // Ensure |request1| never completes.
347   base::RunLoop().RunUntilIdle();
348   EXPECT_THAT(rv1, test::IsError(ERR_IO_PENDING));
349   EXPECT_FALSE(callback1.have_result());
350 }
351 
TEST_F(ContextHostResolverTest,DestroyResolver_CompletedRequests)352 TEST_F(ContextHostResolverTest, DestroyResolver_CompletedRequests) {
353   MockDnsClientRuleList rules;
354   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
355                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
356                          "example.com", kEndpoint.address())),
357                      false /* delay */);
358   rules.emplace_back(
359       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
360       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
361       false /* delay */);
362   SetMockDnsRules(std::move(rules));
363 
364   auto resolver = std::make_unique<ContextHostResolver>(
365       manager_.get(),
366       std::make_unique<ResolveContext>(nullptr /* url_request_context */,
367                                        false /* enable_caching */));
368   std::unique_ptr<HostResolver::ResolveHostRequest> request =
369       resolver->CreateRequest(HostPortPair("example.com", 100),
370                               NetworkAnonymizationKey(), NetLogWithSource(),
371                               std::nullopt);
372 
373   // Complete request and then destroy the resolver.
374   TestCompletionCallback callback;
375   int rv = request->Start(callback.callback());
376   ASSERT_THAT(callback.GetResult(rv), test::IsOk());
377   resolver = nullptr;
378 
379   // Expect completed results are still available.
380   EXPECT_THAT(request->GetResolveErrorInfo().error, test::IsError(net::OK));
381   EXPECT_THAT(request->GetAddressResults()->endpoints(),
382               testing::ElementsAre(kEndpoint));
383 }
384 
385 // Test a request created before resolver destruction but not yet started.
TEST_F(ContextHostResolverTest,DestroyResolver_DelayedStartRequest)386 TEST_F(ContextHostResolverTest, DestroyResolver_DelayedStartRequest) {
387   // Set up delayed result for "example.com".
388   MockDnsClientRuleList rules;
389   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
390                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
391                          "example.com", IPAddress(2, 3, 4, 5))),
392                      true /* delay */);
393   rules.emplace_back(
394       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
395       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
396       false /* delay */);
397 
398   auto resolver = std::make_unique<ContextHostResolver>(
399       manager_.get(),
400       std::make_unique<ResolveContext>(nullptr /* url_request_context */,
401                                        false /* enable_caching */));
402   std::unique_ptr<HostResolver::ResolveHostRequest> request =
403       resolver->CreateRequest(HostPortPair("example.com", 100),
404                               NetworkAnonymizationKey(), NetLogWithSource(),
405                               std::nullopt);
406 
407   resolver = nullptr;
408 
409   TestCompletionCallback callback;
410   int rv = request->Start(callback.callback());
411 
412   EXPECT_THAT(callback.GetResult(rv), test::IsError(ERR_NAME_NOT_RESOLVED));
413   EXPECT_THAT(request->GetResolveErrorInfo().error,
414               test::IsError(ERR_CONTEXT_SHUT_DOWN));
415   EXPECT_FALSE(request->GetAddressResults());
416 }
417 
TEST_F(ContextHostResolverTest,DestroyResolver_DelayedStartDohProbeRequest)418 TEST_F(ContextHostResolverTest, DestroyResolver_DelayedStartDohProbeRequest) {
419   // Set empty MockDnsClient rules to ensure DnsClient is mocked out.
420   MockDnsClientRuleList rules;
421   SetMockDnsRules(std::move(rules));
422 
423   auto context = CreateTestURLRequestContextBuilder()->Build();
424   auto resolve_context = std::make_unique<ResolveContext>(
425       context.get(), false /* enable_caching */);
426   auto resolver = std::make_unique<ContextHostResolver>(
427       manager_.get(), std::move(resolve_context));
428 
429   std::unique_ptr<HostResolver::ProbeRequest> request =
430       resolver->CreateDohProbeRequest();
431 
432   resolver = nullptr;
433 
434   EXPECT_THAT(request->Start(), test::IsError(ERR_CONTEXT_SHUT_DOWN));
435   EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
436 }
437 
TEST_F(ContextHostResolverTest,OnShutdown_PendingRequest)438 TEST_F(ContextHostResolverTest, OnShutdown_PendingRequest) {
439   // Set up delayed result for "example.com".
440   MockDnsClientRuleList rules;
441   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
442                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
443                          "example.com", IPAddress(2, 3, 4, 5))),
444                      true /* delay */);
445   rules.emplace_back(
446       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
447       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
448       false /* delay */);
449   SetMockDnsRules(std::move(rules));
450 
451   auto context = CreateTestURLRequestContextBuilder()->Build();
452   auto resolve_context = std::make_unique<ResolveContext>(
453       context.get(), false /* enable_caching */);
454   auto resolver = std::make_unique<ContextHostResolver>(
455       manager_.get(), std::move(resolve_context));
456   std::unique_ptr<HostResolver::ResolveHostRequest> request =
457       resolver->CreateRequest(HostPortPair("example.com", 100),
458                               NetworkAnonymizationKey(), NetLogWithSource(),
459                               std::nullopt);
460 
461   TestCompletionCallback callback;
462   int rv = request->Start(callback.callback());
463 
464   // Trigger shutdown before allowing request to complete.
465   resolver->OnShutdown();
466   dns_client_->CompleteDelayedTransactions();
467 
468   // Ensure request never completes.
469   base::RunLoop().RunUntilIdle();
470   EXPECT_THAT(rv, test::IsError(ERR_IO_PENDING));
471   EXPECT_FALSE(callback.have_result());
472 }
473 
TEST_F(ContextHostResolverTest,OnShutdown_CompletedRequests)474 TEST_F(ContextHostResolverTest, OnShutdown_CompletedRequests) {
475   MockDnsClientRuleList rules;
476   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
477                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
478                          "example.com", kEndpoint.address())),
479                      false /* delay */);
480   rules.emplace_back(
481       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
482       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
483       false /* delay */);
484   SetMockDnsRules(std::move(rules));
485 
486   auto context = CreateTestURLRequestContextBuilder()->Build();
487   auto resolve_context = std::make_unique<ResolveContext>(
488       context.get(), false /* enable_caching */);
489   auto resolver = std::make_unique<ContextHostResolver>(
490       manager_.get(), std::move(resolve_context));
491   std::unique_ptr<HostResolver::ResolveHostRequest> request =
492       resolver->CreateRequest(HostPortPair("example.com", 100),
493                               NetworkAnonymizationKey(), NetLogWithSource(),
494                               std::nullopt);
495 
496   // Complete request and then shutdown the resolver.
497   TestCompletionCallback callback;
498   int rv = request->Start(callback.callback());
499   ASSERT_THAT(callback.GetResult(rv), test::IsOk());
500   resolver->OnShutdown();
501 
502   // Expect completed results are still available.
503   EXPECT_THAT(request->GetResolveErrorInfo().error, test::IsError(net::OK));
504   EXPECT_THAT(request->GetAddressResults()->endpoints(),
505               testing::ElementsAre(kEndpoint));
506 }
507 
TEST_F(ContextHostResolverTest,OnShutdown_SubsequentRequests)508 TEST_F(ContextHostResolverTest, OnShutdown_SubsequentRequests) {
509   auto context = CreateTestURLRequestContextBuilder()->Build();
510   auto resolve_context = std::make_unique<ResolveContext>(
511       context.get(), false /* enable_caching */);
512   auto resolver = std::make_unique<ContextHostResolver>(
513       manager_.get(), std::move(resolve_context));
514   resolver->OnShutdown();
515 
516   std::unique_ptr<HostResolver::ResolveHostRequest> request1 =
517       resolver->CreateRequest(HostPortPair("example.com", 100),
518                               NetworkAnonymizationKey(), NetLogWithSource(),
519                               std::nullopt);
520   std::unique_ptr<HostResolver::ResolveHostRequest> request2 =
521       resolver->CreateRequest(HostPortPair("127.0.0.1", 100),
522                               NetworkAnonymizationKey(), NetLogWithSource(),
523                               std::nullopt);
524 
525   TestCompletionCallback callback1;
526   int rv1 = request1->Start(callback1.callback());
527   TestCompletionCallback callback2;
528   int rv2 = request2->Start(callback2.callback());
529 
530   EXPECT_THAT(callback1.GetResult(rv1), test::IsError(ERR_CONTEXT_SHUT_DOWN));
531   EXPECT_THAT(request1->GetResolveErrorInfo().error,
532               test::IsError(ERR_CONTEXT_SHUT_DOWN));
533   EXPECT_FALSE(request1->GetAddressResults());
534   EXPECT_THAT(callback2.GetResult(rv2), test::IsError(ERR_CONTEXT_SHUT_DOWN));
535   EXPECT_THAT(request2->GetResolveErrorInfo().error,
536               test::IsError(ERR_CONTEXT_SHUT_DOWN));
537   EXPECT_FALSE(request2->GetAddressResults());
538 }
539 
TEST_F(ContextHostResolverTest,OnShutdown_SubsequentDohProbeRequest)540 TEST_F(ContextHostResolverTest, OnShutdown_SubsequentDohProbeRequest) {
541   // Set empty MockDnsClient rules to ensure DnsClient is mocked out.
542   MockDnsClientRuleList rules;
543   SetMockDnsRules(std::move(rules));
544 
545   auto context = CreateTestURLRequestContextBuilder()->Build();
546   auto resolve_context = std::make_unique<ResolveContext>(
547       context.get(), false /* enable_caching */);
548   auto resolver = std::make_unique<ContextHostResolver>(
549       manager_.get(), std::move(resolve_context));
550   resolver->OnShutdown();
551 
552   std::unique_ptr<HostResolver::ProbeRequest> request =
553       resolver->CreateDohProbeRequest();
554 
555   EXPECT_THAT(request->Start(), test::IsError(ERR_CONTEXT_SHUT_DOWN));
556   EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
557 }
558 
559 // Test a request created before shutdown but not yet started.
TEST_F(ContextHostResolverTest,OnShutdown_DelayedStartRequest)560 TEST_F(ContextHostResolverTest, OnShutdown_DelayedStartRequest) {
561   // Set up delayed result for "example.com".
562   MockDnsClientRuleList rules;
563   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
564                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
565                          "example.com", IPAddress(2, 3, 4, 5))),
566                      true /* delay */);
567   rules.emplace_back(
568       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
569       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
570       false /* delay */);
571 
572   auto context = CreateTestURLRequestContextBuilder()->Build();
573   auto resolve_context = std::make_unique<ResolveContext>(
574       context.get(), false /* enable_caching */);
575   auto resolver = std::make_unique<ContextHostResolver>(
576       manager_.get(), std::move(resolve_context));
577   std::unique_ptr<HostResolver::ResolveHostRequest> request =
578       resolver->CreateRequest(HostPortPair("example.com", 100),
579                               NetworkAnonymizationKey(), NetLogWithSource(),
580                               std::nullopt);
581 
582   resolver->OnShutdown();
583 
584   TestCompletionCallback callback;
585   int rv = request->Start(callback.callback());
586 
587   EXPECT_THAT(callback.GetResult(rv), test::IsError(ERR_NAME_NOT_RESOLVED));
588   EXPECT_THAT(request->GetResolveErrorInfo().error,
589               test::IsError(ERR_CONTEXT_SHUT_DOWN));
590   EXPECT_FALSE(request->GetAddressResults());
591 }
592 
TEST_F(ContextHostResolverTest,OnShutdown_DelayedStartDohProbeRequest)593 TEST_F(ContextHostResolverTest, OnShutdown_DelayedStartDohProbeRequest) {
594   // Set empty MockDnsClient rules to ensure DnsClient is mocked out.
595   MockDnsClientRuleList rules;
596   SetMockDnsRules(std::move(rules));
597 
598   auto context = CreateTestURLRequestContextBuilder()->Build();
599   auto resolve_context = std::make_unique<ResolveContext>(
600       context.get(), false /* enable_caching */);
601   auto resolver = std::make_unique<ContextHostResolver>(
602       manager_.get(), std::move(resolve_context));
603 
604   std::unique_ptr<HostResolver::ProbeRequest> request =
605       resolver->CreateDohProbeRequest();
606 
607   resolver->OnShutdown();
608 
609   EXPECT_THAT(request->Start(), test::IsError(ERR_CONTEXT_SHUT_DOWN));
610   EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
611 }
612 
TEST_F(ContextHostResolverTest,ResolveFromCache)613 TEST_F(ContextHostResolverTest, ResolveFromCache) {
614   auto resolve_context = std::make_unique<ResolveContext>(
615       nullptr /* url_request_context */, true /* enable_caching */);
616   HostCache* host_cache = resolve_context->host_cache();
617   auto resolver = std::make_unique<ContextHostResolver>(
618       manager_.get(), std::move(resolve_context));
619 
620   // Create the cache entry after creating the ContextHostResolver, as
621   // registering into the HostResolverManager initializes and invalidates the
622   // cache.
623   base::SimpleTestTickClock clock;
624   clock.Advance(base::Days(62));  // Arbitrary non-zero time.
625   std::vector<IPEndPoint> expected({kEndpoint});
626   host_cache->Set(
627       HostCache::Key("example.com", DnsQueryType::UNSPECIFIED,
628                      0 /* host_resolver_flags */, HostResolverSource::ANY,
629                      NetworkAnonymizationKey()),
630       HostCache::Entry(OK, expected,
631                        /*aliases=*/std::set<std::string>({"example.com"}),
632                        HostCache::Entry::SOURCE_DNS, base::Days(1)),
633       clock.NowTicks(), base::Days(1));
634   resolver->SetTickClockForTesting(&clock);
635 
636   // Allow stale results and then confirm the result is not stale in order to
637   // make the issue more clear if something is invalidating the cache.
638   HostResolver::ResolveHostParameters parameters;
639   parameters.source = HostResolverSource::LOCAL_ONLY;
640   parameters.cache_usage =
641       HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
642   std::unique_ptr<HostResolver::ResolveHostRequest> request =
643       resolver->CreateRequest(HostPortPair("example.com", 100),
644                               NetworkAnonymizationKey(), NetLogWithSource(),
645                               parameters);
646 
647   TestCompletionCallback callback;
648   int rv = request->Start(callback.callback());
649   EXPECT_THAT(callback.GetResult(rv), test::IsOk());
650   EXPECT_THAT(request->GetResolveErrorInfo().error, test::IsError(net::OK));
651   EXPECT_THAT(request->GetAddressResults()->endpoints(),
652               testing::ElementsAre(kEndpoint));
653   ASSERT_TRUE(request->GetStaleInfo());
654   EXPECT_EQ(0, request->GetStaleInfo().value().network_changes);
655   EXPECT_FALSE(request->GetStaleInfo().value().is_stale());
656 }
657 
TEST_F(ContextHostResolverTest,ResultsAddedToCache)658 TEST_F(ContextHostResolverTest, ResultsAddedToCache) {
659   MockDnsClientRuleList rules;
660   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
661                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
662                          "example.com", kEndpoint.address())),
663                      false /* delay */);
664   rules.emplace_back(
665       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
666       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
667       false /* delay */);
668   SetMockDnsRules(std::move(rules));
669 
670   auto resolve_context = std::make_unique<ResolveContext>(
671       nullptr /* url_request_context */, true /* enable_caching */);
672   auto resolver = std::make_unique<ContextHostResolver>(
673       manager_.get(), std::move(resolve_context));
674 
675   std::unique_ptr<HostResolver::ResolveHostRequest> caching_request =
676       resolver->CreateRequest(HostPortPair("example.com", 103),
677                               NetworkAnonymizationKey(), NetLogWithSource(),
678                               std::nullopt);
679   TestCompletionCallback caching_callback;
680   int rv = caching_request->Start(caching_callback.callback());
681   EXPECT_THAT(caching_callback.GetResult(rv), test::IsOk());
682 
683   HostResolver::ResolveHostParameters local_resolve_parameters;
684   local_resolve_parameters.source = HostResolverSource::LOCAL_ONLY;
685   std::unique_ptr<HostResolver::ResolveHostRequest> cached_request =
686       resolver->CreateRequest(HostPortPair("example.com", 100),
687                               NetworkAnonymizationKey(), NetLogWithSource(),
688                               local_resolve_parameters);
689 
690   TestCompletionCallback callback;
691   rv = cached_request->Start(callback.callback());
692   EXPECT_THAT(callback.GetResult(rv), test::IsOk());
693   EXPECT_THAT(cached_request->GetResolveErrorInfo().error,
694               test::IsError(net::OK));
695   EXPECT_THAT(cached_request->GetAddressResults()->endpoints(),
696               testing::ElementsAre(kEndpoint));
697 }
698 
699 // Do a lookup with a NetworkIsolationKey, and then make sure the entry added to
700 // the cache is in fact using that NetworkIsolationKey.
TEST_F(ContextHostResolverTest,ResultsAddedToCacheWithNetworkIsolationKey)701 TEST_F(ContextHostResolverTest, ResultsAddedToCacheWithNetworkIsolationKey) {
702   const SchemefulSite kSite(GURL("https://origin.test/"));
703   const NetworkIsolationKey kNetworkIsolationKey(kSite, kSite);
704   auto kNetworkAnonymizationKey =
705       net::NetworkAnonymizationKey::CreateSameSite(kSite);
706 
707   base::test::ScopedFeatureList feature_list;
708   feature_list.InitAndEnableFeature(
709       features::kSplitHostCacheByNetworkIsolationKey);
710 
711   MockDnsClientRuleList rules;
712   rules.emplace_back("example.com", dns_protocol::kTypeA, false /* secure */,
713                      MockDnsClientRule::Result(BuildTestDnsAddressResponse(
714                          "example.com", kEndpoint.address())),
715                      false /* delay */);
716   rules.emplace_back(
717       "example.com", dns_protocol::kTypeAAAA, false /* secure */,
718       MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
719       false /* delay */);
720   SetMockDnsRules(std::move(rules));
721 
722   auto resolve_context = std::make_unique<ResolveContext>(
723       nullptr /* url_request_context */, true /* enable_caching */);
724   auto resolver = std::make_unique<ContextHostResolver>(
725       manager_.get(), std::move(resolve_context));
726 
727   std::unique_ptr<HostResolver::ResolveHostRequest> caching_request =
728       resolver->CreateRequest(HostPortPair("example.com", 103),
729                               kNetworkAnonymizationKey, NetLogWithSource(),
730                               std::nullopt);
731   TestCompletionCallback caching_callback;
732   int rv = caching_request->Start(caching_callback.callback());
733   EXPECT_THAT(caching_callback.GetResult(rv), test::IsOk());
734 
735   HostCache::Key cache_key("example.com", DnsQueryType::UNSPECIFIED,
736                            0 /* host_resolver_flags */, HostResolverSource::ANY,
737                            kNetworkAnonymizationKey);
738   EXPECT_TRUE(
739       resolver->GetHostCache()->Lookup(cache_key, base::TimeTicks::Now()));
740 
741   HostCache::Key cache_key_with_empty_nak(
742       "example.com", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
743       HostResolverSource::ANY, NetworkAnonymizationKey());
744   EXPECT_FALSE(resolver->GetHostCache()->Lookup(cache_key_with_empty_nak,
745                                                 base::TimeTicks::Now()));
746 }
747 
748 // Test that the underlying HostCache can receive invalidations from the manager
749 // and that it safely does not receive invalidations after the resolver (and the
750 // HostCache) is destroyed.
TEST_F(ContextHostResolverTest,HostCacheInvalidation)751 TEST_F(ContextHostResolverTest, HostCacheInvalidation) {
752   // Set empty MockDnsClient rules to ensure DnsClient is mocked out.
753   MockDnsClientRuleList rules;
754   SetMockDnsRules(std::move(rules));
755 
756   auto resolve_context = std::make_unique<ResolveContext>(
757       nullptr /* url_request_context */, true /* enable_caching */);
758   ResolveContext* resolve_context_ptr = resolve_context.get();
759   auto resolver = std::make_unique<ContextHostResolver>(
760       manager_.get(), std::move(resolve_context));
761 
762   // No invalidations yet (other than the initialization "invalidation" from
763   // registering the context).
764   ASSERT_EQ(resolve_context_ptr->current_session_for_testing(),
765             dns_client_->GetCurrentSession());
766   ASSERT_EQ(resolve_context_ptr->host_cache()->network_changes(), 1);
767 
768   manager_->InvalidateCachesForTesting();
769   EXPECT_EQ(resolve_context_ptr->current_session_for_testing(),
770             dns_client_->GetCurrentSession());
771   EXPECT_EQ(resolve_context_ptr->host_cache()->network_changes(), 2);
772 
773   // Expect manager to be able to safely do invalidations after an individual
774   // ContextHostResolver has been destroyed (and deregisters its ResolveContext)
775   resolver = nullptr;
776   manager_->InvalidateCachesForTesting();
777 }
778 
779 class FakeServiceEndpontRequestDelegate
780     : public HostResolver::ServiceEndpointRequest::Delegate {
781  public:
OnServiceEndpointsUpdated()782   void OnServiceEndpointsUpdated() override {}
OnServiceEndpointRequestFinished(int rv)783   void OnServiceEndpointRequestFinished(int rv) override { result_ = rv; }
784 
result() const785   std::optional<int> result() const { return result_; }
786 
787  private:
788   std::optional<int> result_;
789 };
790 
791 class ContextHostResolverServiceEndpointTest : public ContextHostResolverTest {
792  public:
793   ContextHostResolverServiceEndpointTest() = default;
794 
795   ~ContextHostResolverServiceEndpointTest() override = default;
796 
SetUp()797   void SetUp() override {
798     ContextHostResolverTest::SetUp();
799 
800     context_ = CreateTestURLRequestContextBuilder()->Build();
801 
802     MockDnsClientRuleList rules;
803     rules.emplace_back("example.com", dns_protocol::kTypeA, /*secure=*/false,
804                        MockDnsClientRule::Result(BuildTestDnsAddressResponse(
805                            "example.com", kEndpoint.address())),
806                        /*delay=*/false, context_.get());
807     rules.emplace_back(
808         "example.com", dns_protocol::kTypeAAAA, /*secure=*/false,
809         MockDnsClientRule::Result(MockDnsClientRule::ResultType::kEmpty),
810         /*delay=*/false, context_.get());
811     SetMockDnsRules(std::move(rules));
812   }
813 
814  protected:
CreateResolver()815   std::unique_ptr<ContextHostResolver> CreateResolver() {
816     auto resolve_context = std::make_unique<ResolveContext>(
817         context_.get(), /*enable_caching=*/false);
818     return std::make_unique<ContextHostResolver>(manager_.get(),
819                                                  std::move(resolve_context));
820   }
821 
822  private:
823   std::unique_ptr<URLRequestContext> context_;
824 };
825 
TEST_F(ContextHostResolverServiceEndpointTest,Resolve)826 TEST_F(ContextHostResolverServiceEndpointTest, Resolve) {
827   std::unique_ptr<ContextHostResolver> resolver = CreateResolver();
828 
829   std::unique_ptr<HostResolver::ServiceEndpointRequest> request =
830       resolver->CreateServiceEndpointRequest(
831           HostResolver::Host(
832               url::SchemeHostPort(url::kHttpsScheme, "example.com", 100)),
833           NetworkAnonymizationKey(), NetLogWithSource(),
834           HostResolver::ResolveHostParameters());
835 
836   FakeServiceEndpontRequestDelegate delegate;
837   int rv = request->Start(&delegate);
838   EXPECT_THAT(rv, test::IsError(ERR_IO_PENDING));
839 
840   RunUntilIdle();
841   EXPECT_THAT(*delegate.result(), test::IsOk());
842   EXPECT_THAT(request->GetEndpointResults(),
843               testing::ElementsAre(
844                   ExpectServiceEndpoint(testing::ElementsAre(kEndpoint))));
845 }
846 
TEST_F(ContextHostResolverServiceEndpointTest,DestroyResolver)847 TEST_F(ContextHostResolverServiceEndpointTest, DestroyResolver) {
848   std::unique_ptr<ContextHostResolver> resolver = CreateResolver();
849 
850   std::unique_ptr<HostResolver::ServiceEndpointRequest> request =
851       resolver->CreateServiceEndpointRequest(
852           HostResolver::Host(
853               url::SchemeHostPort(url::kHttpsScheme, "example.com", 100)),
854           NetworkAnonymizationKey(), NetLogWithSource(),
855           HostResolver::ResolveHostParameters());
856 
857   resolver.reset();
858 
859   FakeServiceEndpontRequestDelegate delegate;
860   int rv = request->Start(&delegate);
861   EXPECT_THAT(rv, test::IsError(ERR_CONTEXT_SHUT_DOWN));
862 }
863 
864 class NetworkBoundResolveContext : public ResolveContext {
865  public:
NetworkBoundResolveContext(URLRequestContext * url_request_context,bool enable_caching,handles::NetworkHandle target_network)866   NetworkBoundResolveContext(URLRequestContext* url_request_context,
867                              bool enable_caching,
868                              handles::NetworkHandle target_network)
869       : ResolveContext(url_request_context, enable_caching),
870         target_network_(target_network) {}
871 
GetTargetNetwork() const872   handles::NetworkHandle GetTargetNetwork() const override {
873     return target_network_;
874   }
875 
876  private:
877   const handles::NetworkHandle target_network_;
878 };
879 
880 // A mock HostResolverProc which returns different IP addresses based on the
881 // `network` parameter received.
882 class NetworkAwareHostResolverProc : public HostResolverProc {
883  public:
NetworkAwareHostResolverProc()884   NetworkAwareHostResolverProc() : HostResolverProc(nullptr) {}
885 
886   NetworkAwareHostResolverProc(const NetworkAwareHostResolverProc&) = delete;
887   NetworkAwareHostResolverProc& operator=(const NetworkAwareHostResolverProc&) =
888       delete;
889 
Resolve(const std::string & host,AddressFamily address_family,HostResolverFlags host_resolver_flags,AddressList * addrlist,int * os_error,handles::NetworkHandle network)890   int Resolve(const std::string& host,
891               AddressFamily address_family,
892               HostResolverFlags host_resolver_flags,
893               AddressList* addrlist,
894               int* os_error,
895               handles::NetworkHandle network) override {
896     // Presume failure
897     *os_error = 1;
898     const auto iter = kResults.find(network);
899     if (iter == kResults.end())
900       return ERR_NETWORK_CHANGED;
901 
902     *os_error = 0;
903     *addrlist = AddressList();
904     addrlist->push_back(ToIPEndPoint(iter->second));
905 
906     return OK;
907   }
908 
Resolve(const std::string & host,AddressFamily address_family,HostResolverFlags host_resolver_flags,AddressList * addrlist,int * os_error)909   int Resolve(const std::string& host,
910               AddressFamily address_family,
911               HostResolverFlags host_resolver_flags,
912               AddressList* addrlist,
913               int* os_error) override {
914     return Resolve(host, address_family, host_resolver_flags, addrlist,
915                    os_error, handles::kInvalidNetworkHandle);
916   }
917 
918   struct IPv4 {
919     uint8_t a;
920     uint8_t b;
921     uint8_t c;
922     uint8_t d;
923   };
924 
925   static constexpr int kPort = 100;
926   static constexpr auto kResults =
927       base::MakeFixedFlatMap<handles::NetworkHandle, IPv4>(
928           {{1, IPv4{1, 2, 3, 4}}, {2, IPv4{8, 8, 8, 8}}});
929 
ToIPEndPoint(const IPv4 & ipv4)930   static IPEndPoint ToIPEndPoint(const IPv4& ipv4) {
931     return IPEndPoint(IPAddress(ipv4.a, ipv4.b, ipv4.c, ipv4.d), kPort);
932   }
933 
934  protected:
935   ~NetworkAwareHostResolverProc() override = default;
936 };
937 
TEST_F(ContextHostResolverTest,ExistingNetworkBoundLookup)938 TEST_F(ContextHostResolverTest, ExistingNetworkBoundLookup) {
939 #if BUILDFLAG(IS_ANDROID)
940   auto scoped_mock_network_change_notifier =
941       std::make_unique<test::ScopedMockNetworkChangeNotifier>();
942   scoped_mock_network_change_notifier->mock_network_change_notifier()
943       ->ForceNetworkHandlesSupported();
944 
945   const url::SchemeHostPort host(url::kHttpsScheme, "example.com",
946                                  NetworkAwareHostResolverProc::kPort);
947   auto resolver_proc = base::MakeRefCounted<NetworkAwareHostResolverProc>();
948   ScopedDefaultHostResolverProc scoped_default_host_resolver;
949   scoped_default_host_resolver.Init(resolver_proc.get());
950 
951   // ResolveContexts bound to a specific network should end up in a call to
952   // Resolve with `network` == context.GetTargetNetwork(). Confirm that we do
953   // indeed receive the IP address associated with that network.
954   for (const auto& iter : NetworkAwareHostResolverProc::kResults) {
955     auto network = iter.first;
956     auto expected_ipv4 = iter.second;
957     auto resolve_context = std::make_unique<NetworkBoundResolveContext>(
958         nullptr /* url_request_context */, false /* enable_caching */, network);
959     // DNS lookups originated from network-bound ResolveContexts must be
960     // resolved through a HostResolverManager bound to the same network.
961     auto manager = HostResolverManager::CreateNetworkBoundHostResolverManager(
962         HostResolver::ManagerOptions(), network, nullptr /* net_log */);
963     auto resolver = std::make_unique<ContextHostResolver>(
964         manager.get(), std::move(resolve_context));
965     std::unique_ptr<HostResolver::ResolveHostRequest> request =
966         resolver->CreateRequest(host, NetworkAnonymizationKey(),
967                                 NetLogWithSource(), std::nullopt);
968 
969     TestCompletionCallback callback;
970     int rv = request->Start(callback.callback());
971     EXPECT_THAT(callback.GetResult(rv), test::IsOk());
972     EXPECT_THAT(request->GetResolveErrorInfo().error, test::IsError(net::OK));
973     ASSERT_EQ(1u, request->GetAddressResults()->endpoints().size());
974     EXPECT_THAT(request->GetAddressResults()->endpoints(),
975                 testing::ElementsAre(
976                     NetworkAwareHostResolverProc::ToIPEndPoint(expected_ipv4)));
977   }
978 #else   // !BUILDFLAG(IS_ANDROID)
979   GTEST_SKIP()
980       << "Network-bound HostResolverManager are supported only on Android.";
981 #endif  // BUILDFLAG(IS_ANDROID)
982 }
983 
TEST_F(ContextHostResolverTest,NotExistingNetworkBoundLookup)984 TEST_F(ContextHostResolverTest, NotExistingNetworkBoundLookup) {
985   const url::SchemeHostPort host(url::kHttpsScheme, "example.com",
986                                  NetworkAwareHostResolverProc::kPort);
987   auto resolver_proc = base::MakeRefCounted<NetworkAwareHostResolverProc>();
988   ScopedDefaultHostResolverProc scoped_default_host_resolver;
989   scoped_default_host_resolver.Init(resolver_proc.get());
990 
991   // Non-bound ResolveContexts should end up with a call to Resolve with
992   // `network` == kInvalidNetwork, which NetworkAwareHostResolverProc fails to
993   // resolve.
994   auto resolve_context = std::make_unique<ResolveContext>(
995       nullptr /* url_request_context */, false /* enable_caching */);
996   auto resolver = std::make_unique<ContextHostResolver>(
997       manager_.get(), std::move(resolve_context));
998   std::unique_ptr<HostResolver::ResolveHostRequest> request =
999       resolver->CreateRequest(host, NetworkAnonymizationKey(),
1000                               NetLogWithSource(), std::nullopt);
1001 
1002   TestCompletionCallback callback;
1003   int rv = request->Start(callback.callback());
1004   EXPECT_THAT(callback.GetResult(rv),
1005               test::IsError(net::ERR_NAME_NOT_RESOLVED));
1006   EXPECT_THAT(request->GetResolveErrorInfo().error,
1007               test::IsError(net::ERR_NETWORK_CHANGED));
1008 }
1009 
1010 // Test that the underlying HostCache does not receive invalidations when its
1011 // ResolveContext/HostResolverManager is bound to a network.
TEST_F(ContextHostResolverTest,NetworkBoundResolverCacheInvalidation)1012 TEST_F(ContextHostResolverTest, NetworkBoundResolverCacheInvalidation) {
1013 #if BUILDFLAG(IS_ANDROID)
1014   auto scoped_mock_network_change_notifier =
1015       std::make_unique<test::ScopedMockNetworkChangeNotifier>();
1016   test::MockNetworkChangeNotifier* mock_ncn =
1017       scoped_mock_network_change_notifier->mock_network_change_notifier();
1018   mock_ncn->ForceNetworkHandlesSupported();
1019 
1020   // The actual network handle doesn't really matter, this test just wants to
1021   // check that all the pieces are in place and configured correctly.
1022   constexpr handles::NetworkHandle network = 2;
1023   manager_ = HostResolverManager::CreateNetworkBoundHostResolverManager(
1024       HostResolver::ManagerOptions(), network, nullptr /* net_log */);
1025   manager_->SetLastIPv6ProbeResultForTesting(true);
1026   // Set empty MockDnsClient rules to ensure DnsClient is mocked out.
1027   MockDnsClientRuleList rules;
1028   SetMockDnsRules(std::move(rules));
1029 
1030   auto resolve_context = std::make_unique<NetworkBoundResolveContext>(
1031       nullptr /* url_request_context */, true /* enable_caching */, network);
1032   ResolveContext* resolve_context_ptr = resolve_context.get();
1033   auto resolver = std::make_unique<ContextHostResolver>(
1034       manager_.get(), std::move(resolve_context));
1035 
1036   // Network events should not trigger cache invalidations
1037   auto network_changes_before_events =
1038       resolve_context_ptr->host_cache()->network_changes();
1039   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
1040   NetworkChangeNotifier::NotifyObserversOfConnectionTypeChangeForTests(
1041       NetworkChangeNotifier::CONNECTION_NONE);
1042   base::RunLoop().RunUntilIdle();
1043   EXPECT_EQ(network_changes_before_events,
1044             resolve_context_ptr->host_cache()->network_changes());
1045 #else   // !BUILDFLAG(IS_ANDROID)
1046   GTEST_SKIP()
1047       << "Network-bound HostResolverManagers are supported only on Android";
1048 #endif  // BUILDFLAG(IS_ANDROID)
1049 }
1050 
1051 }  // namespace net
1052