context_host_resolver_unittest.cc 41 KB

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