host_resolver_unittest.cc 67 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631
  1. // Copyright 2018 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 "services/network/host_resolver.h"
  5. #include <map>
  6. #include <utility>
  7. #include <vector>
  8. #include "base/check.h"
  9. #include "base/memory/raw_ptr.h"
  10. #include "base/run_loop.h"
  11. #include "base/test/bind.h"
  12. #include "base/test/task_environment.h"
  13. #include "base/time/time.h"
  14. #include "build/build_config.h"
  15. #include "mojo/public/cpp/bindings/pending_remote.h"
  16. #include "mojo/public/cpp/bindings/receiver.h"
  17. #include "mojo/public/cpp/bindings/remote.h"
  18. #include "net/base/address_list.h"
  19. #include "net/base/host_port_pair.h"
  20. #include "net/base/ip_address.h"
  21. #include "net/base/ip_endpoint.h"
  22. #include "net/base/net_errors.h"
  23. #include "net/base/network_isolation_key.h"
  24. #include "net/dns/context_host_resolver.h"
  25. #include "net/dns/dns_config.h"
  26. #include "net/dns/dns_test_util.h"
  27. #include "net/dns/host_resolver.h"
  28. #include "net/dns/host_resolver_manager.h"
  29. #include "net/dns/mock_host_resolver.h"
  30. #include "net/dns/public/dns_protocol.h"
  31. #include "net/dns/public/host_resolver_source.h"
  32. #include "net/dns/public/mdns_listener_update_type.h"
  33. #include "net/dns/public/secure_dns_policy.h"
  34. #include "net/log/net_log.h"
  35. #include "net/net_buildflags.h"
  36. #include "net/test/gtest_util.h"
  37. #include "testing/gmock/include/gmock/gmock.h"
  38. #include "testing/gtest/include/gtest/gtest.h"
  39. #include "third_party/abseil-cpp/absl/types/optional.h"
  40. #if BUILDFLAG(IS_ANDROID)
  41. #include "base/android/radio_utils.h"
  42. #include "base/test/metrics/histogram_tester.h"
  43. #include "base/test/scoped_feature_list.h"
  44. #include "net/android/radio_activity_tracker.h"
  45. #include "net/base/features.h"
  46. #include "services/network/radio_monitor_android.h"
  47. #endif
  48. namespace network {
  49. namespace {
  50. class HostResolverTest : public testing::Test {
  51. public:
  52. HostResolverTest() = default;
  53. protected:
  54. base::test::TaskEnvironment task_environment_{
  55. base::test::TaskEnvironment::TimeSource::MOCK_TIME,
  56. base::test::TaskEnvironment::MainThreadType::IO};
  57. };
  58. net::IPEndPoint CreateExpectedEndPoint(const std::string& address,
  59. uint16_t port) {
  60. net::IPAddress ip_address;
  61. CHECK(ip_address.AssignFromIPLiteral(address));
  62. return net::IPEndPoint(ip_address, port);
  63. }
  64. class TestResolveHostClient : public mojom::ResolveHostClient {
  65. public:
  66. // If |run_loop| is non-null, will call RunLoop::Quit() on completion.
  67. TestResolveHostClient(mojo::PendingRemote<mojom::ResolveHostClient>* remote,
  68. base::RunLoop* run_loop)
  69. : receiver_(this, remote->InitWithNewPipeAndPassReceiver()),
  70. complete_(false),
  71. top_level_result_error_(net::ERR_IO_PENDING),
  72. result_error_(net::ERR_UNEXPECTED),
  73. run_loop_(run_loop) {}
  74. void CloseReceiver() { receiver_.reset(); }
  75. void OnComplete(int error,
  76. const net::ResolveErrorInfo& resolve_error_info,
  77. const absl::optional<net::AddressList>& addresses) override {
  78. DCHECK(!complete_);
  79. complete_ = true;
  80. top_level_result_error_ = error;
  81. result_error_ = resolve_error_info.error;
  82. result_addresses_ = addresses;
  83. if (run_loop_)
  84. run_loop_->Quit();
  85. }
  86. void OnTextResults(const std::vector<std::string>& text_results) override {
  87. DCHECK(!complete_);
  88. result_text_ = text_results;
  89. }
  90. void OnHostnameResults(const std::vector<net::HostPortPair>& hosts) override {
  91. DCHECK(!complete_);
  92. result_hosts_ = hosts;
  93. }
  94. bool complete() const { return complete_; }
  95. int top_level_result_error() const {
  96. DCHECK(complete_);
  97. return top_level_result_error_;
  98. }
  99. int result_error() const {
  100. DCHECK(complete_);
  101. return result_error_;
  102. }
  103. const absl::optional<net::AddressList>& result_addresses() const {
  104. DCHECK(complete_);
  105. return result_addresses_;
  106. }
  107. const absl::optional<std::vector<std::string>>& result_text() const {
  108. DCHECK(complete_);
  109. return result_text_;
  110. }
  111. const absl::optional<std::vector<net::HostPortPair>>& result_hosts() const {
  112. DCHECK(complete_);
  113. return result_hosts_;
  114. }
  115. private:
  116. mojo::Receiver<mojom::ResolveHostClient> receiver_{this};
  117. bool complete_;
  118. int top_level_result_error_;
  119. int result_error_;
  120. absl::optional<net::AddressList> result_addresses_;
  121. absl::optional<std::vector<std::string>> result_text_;
  122. absl::optional<std::vector<net::HostPortPair>> result_hosts_;
  123. const raw_ptr<base::RunLoop> run_loop_;
  124. };
  125. class TestMdnsListenClient : public mojom::MdnsListenClient {
  126. public:
  127. using UpdateType = net::MdnsListenerUpdateType;
  128. using UpdateKey = std::pair<UpdateType, net::DnsQueryType>;
  129. explicit TestMdnsListenClient(
  130. mojo::PendingRemote<mojom::MdnsListenClient>* remote)
  131. : receiver_(this, remote->InitWithNewPipeAndPassReceiver()) {}
  132. void OnAddressResult(UpdateType update_type,
  133. net::DnsQueryType result_type,
  134. const net::IPEndPoint& address) override {
  135. address_results_.insert({{update_type, result_type}, address});
  136. }
  137. void OnTextResult(UpdateType update_type,
  138. net::DnsQueryType result_type,
  139. const std::vector<std::string>& text_records) override {
  140. for (auto& text_record : text_records) {
  141. text_results_.insert({{update_type, result_type}, text_record});
  142. }
  143. }
  144. void OnHostnameResult(UpdateType update_type,
  145. net::DnsQueryType result_type,
  146. const net::HostPortPair& host) override {
  147. hostname_results_.insert({{update_type, result_type}, host});
  148. }
  149. void OnUnhandledResult(UpdateType update_type,
  150. net::DnsQueryType result_type) override {
  151. unhandled_results_.insert({update_type, result_type});
  152. }
  153. const std::multimap<UpdateKey, net::IPEndPoint>& address_results() {
  154. return address_results_;
  155. }
  156. const std::multimap<UpdateKey, std::string>& text_results() {
  157. return text_results_;
  158. }
  159. const std::multimap<UpdateKey, net::HostPortPair>& hostname_results() {
  160. return hostname_results_;
  161. }
  162. const std::multiset<UpdateKey>& unhandled_results() {
  163. return unhandled_results_;
  164. }
  165. template <typename T>
  166. static std::pair<UpdateKey, T> CreateExpectedResult(
  167. UpdateType update_type,
  168. net::DnsQueryType query_type,
  169. T result) {
  170. return std::make_pair(std::make_pair(update_type, query_type), result);
  171. }
  172. private:
  173. mojo::Receiver<mojom::MdnsListenClient> receiver_;
  174. std::multimap<UpdateKey, net::IPEndPoint> address_results_;
  175. std::multimap<UpdateKey, std::string> text_results_;
  176. std::multimap<UpdateKey, net::HostPortPair> hostname_results_;
  177. std::multiset<UpdateKey> unhandled_results_;
  178. };
  179. TEST_F(HostResolverTest, Sync) {
  180. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  181. inner_resolver->set_synchronous_mode(true);
  182. inner_resolver->rules()->AddRule("example.test", "1.2.3.4");
  183. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  184. base::RunLoop run_loop;
  185. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  186. mojom::ResolveHostParametersPtr optional_parameters =
  187. mojom::ResolveHostParameters::New();
  188. optional_parameters->control_handle =
  189. control_handle.BindNewPipeAndPassReceiver();
  190. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  191. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  192. resolver.ResolveHost(
  193. net::HostPortPair("example.test", 160), net::NetworkIsolationKey(),
  194. std::move(optional_parameters), std::move(pending_response_client));
  195. run_loop.Run();
  196. EXPECT_EQ(net::OK, response_client.top_level_result_error());
  197. EXPECT_EQ(net::OK, response_client.result_error());
  198. EXPECT_THAT(response_client.result_addresses().value().endpoints(),
  199. testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
  200. EXPECT_FALSE(response_client.result_text());
  201. EXPECT_FALSE(response_client.result_hosts());
  202. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  203. EXPECT_EQ(net::DEFAULT_PRIORITY, inner_resolver->last_request_priority());
  204. }
  205. TEST_F(HostResolverTest, Async) {
  206. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  207. inner_resolver->set_synchronous_mode(false);
  208. inner_resolver->rules()->AddRule("example.test", "1.2.3.4");
  209. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  210. base::RunLoop run_loop;
  211. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  212. mojom::ResolveHostParametersPtr optional_parameters =
  213. mojom::ResolveHostParameters::New();
  214. optional_parameters->control_handle =
  215. control_handle.BindNewPipeAndPassReceiver();
  216. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  217. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  218. resolver.ResolveHost(
  219. net::HostPortPair("example.test", 160), net::NetworkIsolationKey(),
  220. std::move(optional_parameters), std::move(pending_response_client));
  221. bool control_handle_closed = false;
  222. auto connection_error_callback =
  223. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  224. control_handle.set_disconnect_handler(connection_error_callback);
  225. run_loop.Run();
  226. EXPECT_EQ(net::OK, response_client.result_error());
  227. EXPECT_THAT(response_client.result_addresses().value().endpoints(),
  228. testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
  229. EXPECT_FALSE(response_client.result_text());
  230. EXPECT_FALSE(response_client.result_hosts());
  231. EXPECT_TRUE(control_handle_closed);
  232. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  233. EXPECT_EQ(net::DEFAULT_PRIORITY, inner_resolver->last_request_priority());
  234. }
  235. TEST_F(HostResolverTest, DnsQueryType) {
  236. std::unique_ptr<net::HostResolver> inner_resolver =
  237. net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
  238. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  239. mojom::ResolveHostParametersPtr optional_parameters =
  240. mojom::ResolveHostParameters::New();
  241. optional_parameters->dns_query_type = net::DnsQueryType::AAAA;
  242. base::RunLoop run_loop;
  243. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  244. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  245. resolver.ResolveHost(
  246. net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
  247. std::move(optional_parameters), std::move(pending_response_client));
  248. run_loop.Run();
  249. EXPECT_EQ(net::OK, response_client.result_error());
  250. EXPECT_THAT(response_client.result_addresses().value().endpoints(),
  251. testing::ElementsAre(CreateExpectedEndPoint("::1", 160)));
  252. }
  253. TEST_F(HostResolverTest, InitialPriority) {
  254. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  255. inner_resolver->rules()->AddRule("priority.test", "1.2.3.4");
  256. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  257. mojom::ResolveHostParametersPtr optional_parameters =
  258. mojom::ResolveHostParameters::New();
  259. optional_parameters->initial_priority = net::HIGHEST;
  260. base::RunLoop run_loop;
  261. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  262. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  263. resolver.ResolveHost(
  264. net::HostPortPair("priority.test", 80), net::NetworkIsolationKey(),
  265. std::move(optional_parameters), std::move(pending_response_client));
  266. run_loop.Run();
  267. EXPECT_EQ(net::OK, response_client.result_error());
  268. EXPECT_THAT(response_client.result_addresses().value().endpoints(),
  269. testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 80)));
  270. EXPECT_EQ(net::HIGHEST, inner_resolver->last_request_priority());
  271. }
  272. // Make requests specifying a source for host resolution and ensure the correct
  273. // source is requested from the inner resolver.
  274. TEST_F(HostResolverTest, Source) {
  275. constexpr char kDomain[] = "example.com";
  276. constexpr char kAnyResult[] = "1.2.3.4";
  277. constexpr char kSystemResult[] = "127.0.0.1";
  278. constexpr char kDnsResult[] = "168.100.12.23";
  279. constexpr char kMdnsResult[] = "200.1.2.3";
  280. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  281. net::MockHostResolverBase::RuleResolver::RuleKey any_key;
  282. any_key.hostname_pattern = kDomain;
  283. any_key.query_source = net::HostResolverSource::ANY;
  284. inner_resolver->rules()->AddRule(std::move(any_key), kAnyResult);
  285. net::MockHostResolverBase::RuleResolver::RuleKey system_key;
  286. system_key.hostname_pattern = kDomain;
  287. system_key.query_source = net::HostResolverSource::SYSTEM;
  288. inner_resolver->rules()->AddRule(std::move(system_key), kSystemResult);
  289. net::MockHostResolverBase::RuleResolver::RuleKey dns_key;
  290. dns_key.hostname_pattern = kDomain;
  291. dns_key.query_source = net::HostResolverSource::DNS;
  292. inner_resolver->rules()->AddRule(std::move(dns_key), kDnsResult);
  293. net::MockHostResolverBase::RuleResolver::RuleKey mdns_key;
  294. mdns_key.hostname_pattern = kDomain;
  295. mdns_key.query_source = net::HostResolverSource::MULTICAST_DNS;
  296. inner_resolver->rules()->AddRule(std::move(mdns_key), kMdnsResult);
  297. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  298. base::RunLoop any_run_loop;
  299. mojo::PendingRemote<mojom::ResolveHostClient> pending_any_client;
  300. TestResolveHostClient any_client(&pending_any_client, &any_run_loop);
  301. mojom::ResolveHostParametersPtr any_parameters =
  302. mojom::ResolveHostParameters::New();
  303. any_parameters->source = net::HostResolverSource::ANY;
  304. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  305. net::NetworkIsolationKey(), std::move(any_parameters),
  306. std::move(pending_any_client));
  307. base::RunLoop system_run_loop;
  308. mojo::PendingRemote<mojom::ResolveHostClient> pending_system_client;
  309. TestResolveHostClient system_client(&pending_system_client, &system_run_loop);
  310. mojom::ResolveHostParametersPtr system_parameters =
  311. mojom::ResolveHostParameters::New();
  312. system_parameters->source = net::HostResolverSource::SYSTEM;
  313. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  314. net::NetworkIsolationKey(), std::move(system_parameters),
  315. std::move(pending_system_client));
  316. base::RunLoop dns_run_loop;
  317. mojo::PendingRemote<mojom::ResolveHostClient> pending_dns_client;
  318. TestResolveHostClient dns_client(&pending_dns_client, &dns_run_loop);
  319. mojom::ResolveHostParametersPtr dns_parameters =
  320. mojom::ResolveHostParameters::New();
  321. dns_parameters->source = net::HostResolverSource::DNS;
  322. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  323. net::NetworkIsolationKey(), std::move(dns_parameters),
  324. std::move(pending_dns_client));
  325. any_run_loop.Run();
  326. system_run_loop.Run();
  327. dns_run_loop.Run();
  328. EXPECT_EQ(net::OK, any_client.result_error());
  329. EXPECT_THAT(any_client.result_addresses().value().endpoints(),
  330. testing::ElementsAre(CreateExpectedEndPoint(kAnyResult, 80)));
  331. EXPECT_EQ(net::OK, system_client.result_error());
  332. EXPECT_THAT(system_client.result_addresses().value().endpoints(),
  333. testing::ElementsAre(CreateExpectedEndPoint(kSystemResult, 80)));
  334. EXPECT_EQ(net::OK, dns_client.result_error());
  335. EXPECT_THAT(dns_client.result_addresses().value().endpoints(),
  336. testing::ElementsAre(CreateExpectedEndPoint(kDnsResult, 80)));
  337. #if BUILDFLAG(ENABLE_MDNS)
  338. base::RunLoop mdns_run_loop;
  339. mojo::PendingRemote<mojom::ResolveHostClient> pending_mdns_client;
  340. TestResolveHostClient mdns_client(&pending_mdns_client, &mdns_run_loop);
  341. mojom::ResolveHostParametersPtr mdns_parameters =
  342. mojom::ResolveHostParameters::New();
  343. mdns_parameters->source = net::HostResolverSource::MULTICAST_DNS;
  344. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  345. net::NetworkIsolationKey(), std::move(mdns_parameters),
  346. std::move(pending_mdns_client));
  347. mdns_run_loop.Run();
  348. EXPECT_EQ(net::OK, mdns_client.result_error());
  349. EXPECT_THAT(mdns_client.result_addresses().value().endpoints(),
  350. testing::ElementsAre(CreateExpectedEndPoint(kMdnsResult, 80)));
  351. #endif // BUILDFLAG(ENABLE_MDNS)
  352. }
  353. // Test that cached results are properly keyed by requested source.
  354. TEST_F(HostResolverTest, SeparateCacheBySource) {
  355. constexpr char kDomain[] = "example.com";
  356. constexpr char kAnyResultOriginal[] = "1.2.3.4";
  357. constexpr char kSystemResultOriginal[] = "127.0.0.1";
  358. auto inner_resolver = std::make_unique<net::MockCachingHostResolver>();
  359. net::MockHostResolverBase::RuleResolver::RuleKey any_key;
  360. any_key.hostname_pattern = kDomain;
  361. any_key.query_source = net::HostResolverSource::ANY;
  362. inner_resolver->rules()->AddRule(any_key, kAnyResultOriginal);
  363. net::MockHostResolverBase::RuleResolver::RuleKey system_key;
  364. system_key.hostname_pattern = kDomain;
  365. system_key.query_source = net::HostResolverSource::SYSTEM;
  366. inner_resolver->rules()->AddRule(system_key, kSystemResultOriginal);
  367. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  368. // Load SYSTEM result into cache.
  369. base::RunLoop system_run_loop;
  370. mojo::PendingRemote<mojom::ResolveHostClient> pending_system_client_ptr;
  371. TestResolveHostClient system_client(&pending_system_client_ptr,
  372. &system_run_loop);
  373. mojom::ResolveHostParametersPtr system_parameters =
  374. mojom::ResolveHostParameters::New();
  375. system_parameters->source = net::HostResolverSource::SYSTEM;
  376. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  377. net::NetworkIsolationKey(), std::move(system_parameters),
  378. std::move(pending_system_client_ptr));
  379. system_run_loop.Run();
  380. ASSERT_EQ(net::OK, system_client.result_error());
  381. EXPECT_THAT(
  382. system_client.result_addresses().value().endpoints(),
  383. testing::ElementsAre(CreateExpectedEndPoint(kSystemResultOriginal, 80)));
  384. // Change |inner_resolver| rules to ensure results are coming from cache or
  385. // not based on whether they resolve to the old or new value.
  386. constexpr char kAnyResultFresh[] = "111.222.1.1";
  387. constexpr char kSystemResultFresh[] = "111.222.1.2";
  388. inner_resolver->rules()->ClearRules();
  389. inner_resolver->rules()->AddRule(any_key, kAnyResultFresh);
  390. inner_resolver->rules()->AddRule(system_key, kSystemResultFresh);
  391. base::RunLoop cached_run_loop;
  392. mojo::PendingRemote<mojom::ResolveHostClient> pending_cached_client;
  393. TestResolveHostClient cached_client(&pending_cached_client, &cached_run_loop);
  394. mojom::ResolveHostParametersPtr cached_parameters =
  395. mojom::ResolveHostParameters::New();
  396. cached_parameters->source = net::HostResolverSource::SYSTEM;
  397. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  398. net::NetworkIsolationKey(), std::move(cached_parameters),
  399. std::move(pending_cached_client));
  400. base::RunLoop uncached_run_loop;
  401. mojo::PendingRemote<mojom::ResolveHostClient> pending_uncached_client;
  402. TestResolveHostClient uncached_client(&pending_uncached_client,
  403. &uncached_run_loop);
  404. mojom::ResolveHostParametersPtr uncached_parameters =
  405. mojom::ResolveHostParameters::New();
  406. uncached_parameters->source = net::HostResolverSource::ANY;
  407. resolver.ResolveHost(
  408. net::HostPortPair(kDomain, 80), net::NetworkIsolationKey(),
  409. std::move(uncached_parameters), std::move(pending_uncached_client));
  410. cached_run_loop.Run();
  411. uncached_run_loop.Run();
  412. EXPECT_EQ(net::OK, cached_client.result_error());
  413. EXPECT_THAT(
  414. cached_client.result_addresses().value().endpoints(),
  415. testing::ElementsAre(CreateExpectedEndPoint(kSystemResultOriginal, 80)));
  416. EXPECT_EQ(net::OK, uncached_client.result_error());
  417. EXPECT_THAT(
  418. uncached_client.result_addresses().value().endpoints(),
  419. testing::ElementsAre(CreateExpectedEndPoint(kAnyResultFresh, 80)));
  420. }
  421. TEST_F(HostResolverTest, CacheDisabled) {
  422. constexpr char kDomain[] = "example.com";
  423. constexpr char kResultOriginal[] = "1.2.3.4";
  424. auto inner_resolver = std::make_unique<net::MockCachingHostResolver>();
  425. inner_resolver->rules()->AddRule(kDomain, kResultOriginal);
  426. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  427. // Load result into cache.
  428. base::RunLoop run_loop;
  429. mojo::PendingRemote<mojom::ResolveHostClient> pending_client;
  430. TestResolveHostClient client(&pending_client, &run_loop);
  431. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  432. net::NetworkIsolationKey(), nullptr,
  433. std::move(pending_client));
  434. run_loop.Run();
  435. ASSERT_EQ(net::OK, client.result_error());
  436. EXPECT_THAT(
  437. client.result_addresses().value().endpoints(),
  438. testing::ElementsAre(CreateExpectedEndPoint(kResultOriginal, 80)));
  439. // Change |inner_resolver| rules to ensure results are coming from cache or
  440. // not based on whether they resolve to the old or new value.
  441. constexpr char kResultFresh[] = "111.222.1.1";
  442. inner_resolver->rules()->ClearRules();
  443. inner_resolver->rules()->AddRule(kDomain, kResultFresh);
  444. base::RunLoop cached_run_loop;
  445. mojo::PendingRemote<mojom::ResolveHostClient> pending_cached_client;
  446. TestResolveHostClient cached_client(&pending_cached_client, &cached_run_loop);
  447. mojom::ResolveHostParametersPtr cached_parameters =
  448. mojom::ResolveHostParameters::New();
  449. cached_parameters->cache_usage =
  450. mojom::ResolveHostParameters::CacheUsage::ALLOWED;
  451. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  452. net::NetworkIsolationKey(), std::move(cached_parameters),
  453. std::move(pending_cached_client));
  454. cached_run_loop.Run();
  455. EXPECT_EQ(net::OK, cached_client.result_error());
  456. EXPECT_THAT(
  457. cached_client.result_addresses().value().endpoints(),
  458. testing::ElementsAre(CreateExpectedEndPoint(kResultOriginal, 80)));
  459. base::RunLoop uncached_run_loop;
  460. mojo::PendingRemote<mojom::ResolveHostClient> pending_uncached_client;
  461. TestResolveHostClient uncached_client(&pending_uncached_client,
  462. &uncached_run_loop);
  463. mojom::ResolveHostParametersPtr uncached_parameters =
  464. mojom::ResolveHostParameters::New();
  465. uncached_parameters->cache_usage =
  466. mojom::ResolveHostParameters::CacheUsage::DISALLOWED;
  467. resolver.ResolveHost(
  468. net::HostPortPair(kDomain, 80), net::NetworkIsolationKey(),
  469. std::move(uncached_parameters), std::move(pending_uncached_client));
  470. uncached_run_loop.Run();
  471. EXPECT_EQ(net::OK, uncached_client.result_error());
  472. EXPECT_THAT(uncached_client.result_addresses().value().endpoints(),
  473. testing::ElementsAre(CreateExpectedEndPoint(kResultFresh, 80)));
  474. }
  475. TEST_F(HostResolverTest, CacheStaleAllowed) {
  476. constexpr char kDomain[] = "example.com";
  477. constexpr char kResultOriginal[] = "1.2.3.4";
  478. auto inner_resolver = std::make_unique<net::MockCachingHostResolver>();
  479. inner_resolver->rules()->AddRule(kDomain, kResultOriginal);
  480. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  481. // Load result into cache.
  482. base::RunLoop run_loop;
  483. mojo::PendingRemote<mojom::ResolveHostClient> pending_client;
  484. TestResolveHostClient client(&pending_client, &run_loop);
  485. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  486. net::NetworkIsolationKey(), nullptr,
  487. std::move(pending_client));
  488. run_loop.Run();
  489. ASSERT_EQ(net::OK, client.result_error());
  490. EXPECT_THAT(
  491. client.result_addresses().value().endpoints(),
  492. testing::ElementsAre(CreateExpectedEndPoint(kResultOriginal, 80)));
  493. // Change |inner_resolver| rules to ensure results are coming from cache or
  494. // not based on whether they resolve to the old or new value.
  495. constexpr char kResultFresh[] = "111.222.1.1";
  496. inner_resolver->rules()->ClearRules();
  497. inner_resolver->rules()->AddRule(kDomain, kResultFresh);
  498. // MockHostResolver gives cache entries a 1 min TTL, so simulate a day
  499. // passing, which is more than long enough for the cached results to become
  500. // stale.
  501. task_environment_.FastForwardBy(base::Days(1));
  502. // Fetching stale results returns the original cached value.
  503. base::RunLoop cached_run_loop;
  504. mojo::PendingRemote<mojom::ResolveHostClient> pending_cached_client;
  505. TestResolveHostClient cached_client(&pending_cached_client, &cached_run_loop);
  506. mojom::ResolveHostParametersPtr cached_parameters =
  507. mojom::ResolveHostParameters::New();
  508. cached_parameters->cache_usage =
  509. mojom::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
  510. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  511. net::NetworkIsolationKey(), std::move(cached_parameters),
  512. std::move(pending_cached_client));
  513. cached_run_loop.Run();
  514. EXPECT_EQ(net::OK, cached_client.result_error());
  515. EXPECT_THAT(
  516. cached_client.result_addresses().value().endpoints(),
  517. testing::ElementsAre(CreateExpectedEndPoint(kResultOriginal, 80)));
  518. // Resolution where only non-stale cache usage is allowed returns the new
  519. // value.
  520. base::RunLoop uncached_run_loop;
  521. mojo::PendingRemote<mojom::ResolveHostClient> pending_uncached_client;
  522. TestResolveHostClient uncached_client(&pending_uncached_client,
  523. &uncached_run_loop);
  524. mojom::ResolveHostParametersPtr uncached_parameters =
  525. mojom::ResolveHostParameters::New();
  526. uncached_parameters->cache_usage =
  527. mojom::ResolveHostParameters::CacheUsage::ALLOWED;
  528. resolver.ResolveHost(
  529. net::HostPortPair(kDomain, 80), net::NetworkIsolationKey(),
  530. std::move(uncached_parameters), std::move(pending_uncached_client));
  531. uncached_run_loop.Run();
  532. EXPECT_EQ(net::OK, uncached_client.result_error());
  533. EXPECT_THAT(uncached_client.result_addresses().value().endpoints(),
  534. testing::ElementsAre(CreateExpectedEndPoint(kResultFresh, 80)));
  535. }
  536. // Test for a resolve with a result only in the cache and error if the cache is
  537. // disabled.
  538. TEST_F(HostResolverTest, CacheDisabled_ErrorResults) {
  539. constexpr char kDomain[] = "example.com";
  540. constexpr char kResult[] = "1.2.3.4";
  541. auto inner_resolver = std::make_unique<net::MockCachingHostResolver>();
  542. inner_resolver->rules()->AddRule(kDomain, kResult);
  543. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  544. // Load initial result into cache.
  545. base::RunLoop run_loop;
  546. mojo::PendingRemote<mojom::ResolveHostClient> pending_client;
  547. TestResolveHostClient client(&pending_client, &run_loop);
  548. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  549. net::NetworkIsolationKey(), nullptr,
  550. std::move(pending_client));
  551. run_loop.Run();
  552. ASSERT_EQ(net::OK, client.result_error());
  553. // Change |inner_resolver| rules to an error.
  554. inner_resolver->rules()->ClearRules();
  555. inner_resolver->rules()->AddSimulatedFailure(kDomain);
  556. // Resolves for |kFreshErrorDomain| should result in error only when cache is
  557. // disabled because success was cached.
  558. base::RunLoop cached_run_loop;
  559. mojo::PendingRemote<mojom::ResolveHostClient> pending_cached_client;
  560. TestResolveHostClient cached_client(&pending_cached_client, &cached_run_loop);
  561. mojom::ResolveHostParametersPtr cached_parameters =
  562. mojom::ResolveHostParameters::New();
  563. cached_parameters->cache_usage =
  564. mojom::ResolveHostParameters::CacheUsage::ALLOWED;
  565. resolver.ResolveHost(net::HostPortPair(kDomain, 80),
  566. net::NetworkIsolationKey(), std::move(cached_parameters),
  567. std::move(pending_cached_client));
  568. cached_run_loop.Run();
  569. EXPECT_EQ(net::OK, cached_client.result_error());
  570. base::RunLoop uncached_run_loop;
  571. mojo::PendingRemote<mojom::ResolveHostClient> pending_uncached_client;
  572. TestResolveHostClient uncached_client(&pending_uncached_client,
  573. &uncached_run_loop);
  574. mojom::ResolveHostParametersPtr uncached_parameters =
  575. mojom::ResolveHostParameters::New();
  576. uncached_parameters->cache_usage =
  577. mojom::ResolveHostParameters::CacheUsage::DISALLOWED;
  578. resolver.ResolveHost(
  579. net::HostPortPair(kDomain, 80), net::NetworkIsolationKey(),
  580. std::move(uncached_parameters), std::move(pending_uncached_client));
  581. uncached_run_loop.Run();
  582. EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, uncached_client.result_error());
  583. }
  584. TEST_F(HostResolverTest, IncludeCanonicalName) {
  585. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  586. inner_resolver->rules()->AddRuleWithFlags("example.com", "123.0.12.24",
  587. net::HOST_RESOLVER_CANONNAME,
  588. {"canonicalexample.com"});
  589. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  590. mojom::ResolveHostParametersPtr optional_parameters =
  591. mojom::ResolveHostParameters::New();
  592. optional_parameters->include_canonical_name = true;
  593. base::RunLoop run_loop;
  594. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  595. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  596. resolver.ResolveHost(
  597. net::HostPortPair("example.com", 80), net::NetworkIsolationKey(),
  598. std::move(optional_parameters), std::move(pending_response_client));
  599. run_loop.Run();
  600. EXPECT_EQ(net::OK, response_client.result_error());
  601. EXPECT_THAT(response_client.result_addresses().value().endpoints(),
  602. testing::ElementsAre(CreateExpectedEndPoint("123.0.12.24", 80)));
  603. EXPECT_THAT(response_client.result_addresses().value().dns_aliases(),
  604. testing::ElementsAre("canonicalexample.com"));
  605. }
  606. TEST_F(HostResolverTest, LoopbackOnly) {
  607. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  608. inner_resolver->rules()->AddRuleWithFlags("example.com", "127.0.12.24",
  609. net::HOST_RESOLVER_LOOPBACK_ONLY);
  610. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  611. mojom::ResolveHostParametersPtr optional_parameters =
  612. mojom::ResolveHostParameters::New();
  613. optional_parameters->loopback_only = true;
  614. base::RunLoop run_loop;
  615. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  616. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  617. resolver.ResolveHost(
  618. net::HostPortPair("example.com", 80), net::NetworkIsolationKey(),
  619. std::move(optional_parameters), std::move(pending_response_client));
  620. run_loop.Run();
  621. EXPECT_EQ(net::OK, response_client.result_error());
  622. EXPECT_THAT(response_client.result_addresses().value().endpoints(),
  623. testing::ElementsAre(CreateExpectedEndPoint("127.0.12.24", 80)));
  624. }
  625. TEST_F(HostResolverTest, HandlesSecureDnsPolicyParameter) {
  626. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  627. inner_resolver->rules()->AddRule("secure.test", "1.2.3.4");
  628. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  629. mojom::ResolveHostParametersPtr optional_parameters =
  630. mojom::ResolveHostParameters::New();
  631. optional_parameters->secure_dns_policy =
  632. network::mojom::SecureDnsPolicy::DISABLE;
  633. base::RunLoop run_loop;
  634. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  635. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  636. resolver.ResolveHost(
  637. net::HostPortPair("secure.test", 80), net::NetworkIsolationKey(),
  638. std::move(optional_parameters), std::move(pending_response_client));
  639. run_loop.Run();
  640. EXPECT_EQ(net::OK, response_client.result_error());
  641. EXPECT_THAT(response_client.result_addresses().value().endpoints(),
  642. testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 80)));
  643. EXPECT_EQ(net::SecureDnsPolicy::kDisable,
  644. inner_resolver->last_secure_dns_policy());
  645. }
  646. TEST_F(HostResolverTest, Failure_Sync) {
  647. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  648. inner_resolver->rules()->AddSimulatedFailure("example.com");
  649. inner_resolver->set_synchronous_mode(true);
  650. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  651. base::RunLoop run_loop;
  652. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  653. mojom::ResolveHostParametersPtr optional_parameters =
  654. mojom::ResolveHostParameters::New();
  655. optional_parameters->control_handle =
  656. control_handle.BindNewPipeAndPassReceiver();
  657. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  658. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  659. resolver.ResolveHost(
  660. net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
  661. std::move(optional_parameters), std::move(pending_response_client));
  662. run_loop.Run();
  663. EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED,
  664. response_client.top_level_result_error());
  665. EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, response_client.result_error());
  666. EXPECT_FALSE(response_client.result_addresses());
  667. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  668. }
  669. TEST_F(HostResolverTest, Failure_Async) {
  670. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  671. inner_resolver->rules()->AddSimulatedFailure("example.com");
  672. inner_resolver->set_synchronous_mode(false);
  673. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  674. base::RunLoop run_loop;
  675. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  676. mojom::ResolveHostParametersPtr optional_parameters =
  677. mojom::ResolveHostParameters::New();
  678. optional_parameters->control_handle =
  679. control_handle.BindNewPipeAndPassReceiver();
  680. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  681. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  682. resolver.ResolveHost(
  683. net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
  684. std::move(optional_parameters), std::move(pending_response_client));
  685. bool control_handle_closed = false;
  686. auto connection_error_callback =
  687. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  688. control_handle.set_disconnect_handler(connection_error_callback);
  689. run_loop.Run();
  690. EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, response_client.result_error());
  691. EXPECT_FALSE(response_client.result_addresses());
  692. EXPECT_TRUE(control_handle_closed);
  693. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  694. }
  695. TEST_F(HostResolverTest, NetworkIsolationKey) {
  696. const url::Origin kOrigin = url::Origin::Create(GURL("https://foo.test/"));
  697. const net::NetworkIsolationKey kNetworkIsolationKey(kOrigin, kOrigin);
  698. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  699. inner_resolver->rules()->AddRule("nik.test", "1.2.3.4");
  700. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  701. base::RunLoop run_loop;
  702. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  703. mojom::ResolveHostParametersPtr optional_parameters =
  704. mojom::ResolveHostParameters::New();
  705. optional_parameters->control_handle =
  706. control_handle.BindNewPipeAndPassReceiver();
  707. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  708. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  709. resolver.ResolveHost(net::HostPortPair("nik.test", 160), kNetworkIsolationKey,
  710. std::move(optional_parameters),
  711. std::move(pending_response_client));
  712. run_loop.Run();
  713. EXPECT_EQ(net::OK, response_client.result_error());
  714. EXPECT_THAT(response_client.result_addresses().value().endpoints(),
  715. testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
  716. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  717. EXPECT_EQ(kNetworkIsolationKey,
  718. inner_resolver->last_request_network_isolation_key());
  719. }
  720. TEST_F(HostResolverTest, NoOptionalParameters) {
  721. std::unique_ptr<net::HostResolver> inner_resolver =
  722. net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
  723. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  724. base::RunLoop run_loop;
  725. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  726. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  727. // Resolve "localhost" because it should always resolve fast and locally, even
  728. // when using a real HostResolver.
  729. resolver.ResolveHost(net::HostPortPair("localhost", 80),
  730. net::NetworkIsolationKey(), nullptr,
  731. std::move(pending_response_client));
  732. run_loop.Run();
  733. EXPECT_EQ(net::OK, response_client.result_error());
  734. EXPECT_THAT(
  735. response_client.result_addresses().value().endpoints(),
  736. testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
  737. CreateExpectedEndPoint("::1", 80)));
  738. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  739. }
  740. TEST_F(HostResolverTest, NoControlHandle) {
  741. std::unique_ptr<net::HostResolver> inner_resolver =
  742. net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
  743. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  744. base::RunLoop run_loop;
  745. mojom::ResolveHostParametersPtr optional_parameters =
  746. mojom::ResolveHostParameters::New();
  747. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  748. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  749. // Resolve "localhost" because it should always resolve fast and locally, even
  750. // when using a real HostResolver.
  751. resolver.ResolveHost(
  752. net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
  753. std::move(optional_parameters), std::move(pending_response_client));
  754. run_loop.Run();
  755. EXPECT_EQ(net::OK, response_client.result_error());
  756. EXPECT_THAT(
  757. response_client.result_addresses().value().endpoints(),
  758. testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
  759. CreateExpectedEndPoint("::1", 80)));
  760. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  761. }
  762. TEST_F(HostResolverTest, CloseControlHandle) {
  763. std::unique_ptr<net::HostResolver> inner_resolver =
  764. net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
  765. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  766. base::RunLoop run_loop;
  767. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  768. mojom::ResolveHostParametersPtr optional_parameters =
  769. mojom::ResolveHostParameters::New();
  770. optional_parameters->control_handle =
  771. control_handle.BindNewPipeAndPassReceiver();
  772. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  773. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  774. // Resolve "localhost" because it should always resolve fast and locally, even
  775. // when using a real HostResolver.
  776. resolver.ResolveHost(
  777. net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
  778. std::move(optional_parameters), std::move(pending_response_client));
  779. control_handle.reset();
  780. run_loop.Run();
  781. EXPECT_EQ(net::OK, response_client.result_error());
  782. EXPECT_THAT(
  783. response_client.result_addresses().value().endpoints(),
  784. testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 160),
  785. CreateExpectedEndPoint("::1", 160)));
  786. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  787. }
  788. TEST_F(HostResolverTest, Cancellation) {
  789. // Use a HangingHostResolver, so the test can ensure the request won't be
  790. // completed before the cancellation arrives.
  791. auto inner_resolver = std::make_unique<net::HangingHostResolver>();
  792. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  793. ASSERT_EQ(0, inner_resolver->num_cancellations());
  794. base::RunLoop run_loop;
  795. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  796. mojom::ResolveHostParametersPtr optional_parameters =
  797. mojom::ResolveHostParameters::New();
  798. optional_parameters->control_handle =
  799. control_handle.BindNewPipeAndPassReceiver();
  800. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  801. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  802. resolver.ResolveHost(
  803. net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
  804. std::move(optional_parameters), std::move(pending_response_client));
  805. bool control_handle_closed = false;
  806. auto connection_error_callback =
  807. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  808. control_handle.set_disconnect_handler(connection_error_callback);
  809. control_handle->Cancel(net::ERR_ABORTED);
  810. run_loop.Run();
  811. // On cancellation, should receive an ERR_FAILED result, and the internal
  812. // resolver request should have been cancelled.
  813. EXPECT_EQ(net::ERR_ABORTED, response_client.result_error());
  814. EXPECT_FALSE(response_client.result_addresses());
  815. EXPECT_EQ(1, inner_resolver->num_cancellations());
  816. EXPECT_TRUE(control_handle_closed);
  817. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  818. }
  819. TEST_F(HostResolverTest, Cancellation_SubsequentRequest) {
  820. std::unique_ptr<net::HostResolver> inner_resolver =
  821. net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
  822. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  823. base::RunLoop run_loop;
  824. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  825. mojom::ResolveHostParametersPtr optional_parameters =
  826. mojom::ResolveHostParameters::New();
  827. optional_parameters->control_handle =
  828. control_handle.BindNewPipeAndPassReceiver();
  829. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  830. TestResolveHostClient response_client(&pending_response_client, nullptr);
  831. resolver.ResolveHost(
  832. net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
  833. std::move(optional_parameters), std::move(pending_response_client));
  834. control_handle->Cancel(net::ERR_ABORTED);
  835. run_loop.RunUntilIdle();
  836. // Not using a hanging resolver, so could be ERR_ABORTED or OK depending on
  837. // timing of the cancellation.
  838. EXPECT_TRUE(response_client.result_error() == net::ERR_ABORTED ||
  839. response_client.result_error() == net::OK);
  840. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  841. // Subsequent requests should be unaffected by the cancellation.
  842. base::RunLoop run_loop2;
  843. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client2;
  844. TestResolveHostClient response_client2(&pending_response_client2, &run_loop2);
  845. resolver.ResolveHost(net::HostPortPair("localhost", 80),
  846. net::NetworkIsolationKey(), nullptr,
  847. std::move(pending_response_client2));
  848. run_loop2.Run();
  849. EXPECT_EQ(net::OK, response_client2.result_error());
  850. EXPECT_THAT(
  851. response_client2.result_addresses().value().endpoints(),
  852. testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
  853. CreateExpectedEndPoint("::1", 80)));
  854. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  855. }
  856. TEST_F(HostResolverTest, DestroyResolver) {
  857. // Use a HangingHostResolver, so the test can ensure the request won't be
  858. // completed before the cancellation arrives.
  859. auto inner_resolver = std::make_unique<net::HangingHostResolver>();
  860. auto resolver =
  861. std::make_unique<HostResolver>(inner_resolver.get(), net::NetLog::Get());
  862. ASSERT_EQ(0, inner_resolver->num_cancellations());
  863. base::RunLoop run_loop;
  864. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  865. mojom::ResolveHostParametersPtr optional_parameters =
  866. mojom::ResolveHostParameters::New();
  867. optional_parameters->control_handle =
  868. control_handle.BindNewPipeAndPassReceiver();
  869. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  870. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  871. resolver->ResolveHost(
  872. net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
  873. std::move(optional_parameters), std::move(pending_response_client));
  874. bool control_handle_closed = false;
  875. auto connection_error_callback =
  876. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  877. control_handle.set_disconnect_handler(connection_error_callback);
  878. resolver = nullptr;
  879. run_loop.Run();
  880. // On context destruction, should receive an ERR_FAILED result, and the
  881. // internal resolver request should have been cancelled.
  882. EXPECT_EQ(net::ERR_FAILED, response_client.result_error());
  883. EXPECT_FALSE(response_client.result_addresses());
  884. EXPECT_EQ(1, inner_resolver->num_cancellations());
  885. EXPECT_TRUE(control_handle_closed);
  886. }
  887. TEST_F(HostResolverTest, CloseClient) {
  888. // Use a HangingHostResolver, so the test can ensure the request won't be
  889. // completed before the cancellation arrives.
  890. auto inner_resolver = std::make_unique<net::HangingHostResolver>();
  891. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  892. ASSERT_EQ(0, inner_resolver->num_cancellations());
  893. base::RunLoop run_loop;
  894. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  895. mojom::ResolveHostParametersPtr optional_parameters =
  896. mojom::ResolveHostParameters::New();
  897. optional_parameters->control_handle =
  898. control_handle.BindNewPipeAndPassReceiver();
  899. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  900. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  901. resolver.ResolveHost(
  902. net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
  903. std::move(optional_parameters), std::move(pending_response_client));
  904. bool control_handle_closed = false;
  905. auto connection_error_callback =
  906. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  907. control_handle.set_disconnect_handler(connection_error_callback);
  908. response_client.CloseReceiver();
  909. run_loop.RunUntilIdle();
  910. // Response pipe is closed, so no results to check. Internal request should be
  911. // cancelled.
  912. EXPECT_FALSE(response_client.complete());
  913. EXPECT_EQ(1, inner_resolver->num_cancellations());
  914. EXPECT_TRUE(control_handle_closed);
  915. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  916. }
  917. TEST_F(HostResolverTest, CloseClient_SubsequentRequest) {
  918. std::unique_ptr<net::HostResolver> inner_resolver =
  919. net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
  920. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  921. base::RunLoop run_loop;
  922. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  923. TestResolveHostClient response_client(&pending_response_client, nullptr);
  924. resolver.ResolveHost(net::HostPortPair("localhost", 80),
  925. net::NetworkIsolationKey(), nullptr,
  926. std::move(pending_response_client));
  927. response_client.CloseReceiver();
  928. run_loop.RunUntilIdle();
  929. // Not using a hanging resolver, so could be incomplete or OK depending on
  930. // timing of the cancellation.
  931. EXPECT_TRUE(!response_client.complete() ||
  932. response_client.result_error() == net::OK);
  933. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  934. // Subsequent requests should be unaffected by the cancellation.
  935. base::RunLoop run_loop2;
  936. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client2;
  937. TestResolveHostClient response_client2(&pending_response_client2, &run_loop2);
  938. resolver.ResolveHost(net::HostPortPair("localhost", 80),
  939. net::NetworkIsolationKey(), nullptr,
  940. std::move(pending_response_client2));
  941. run_loop2.Run();
  942. EXPECT_EQ(net::OK, response_client2.result_error());
  943. EXPECT_THAT(
  944. response_client2.result_addresses().value().endpoints(),
  945. testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
  946. CreateExpectedEndPoint("::1", 80)));
  947. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  948. }
  949. TEST_F(HostResolverTest, Binding) {
  950. mojo::Remote<mojom::HostResolver> resolver_remote;
  951. HostResolver* shutdown_resolver = nullptr;
  952. HostResolver::ConnectionShutdownCallback shutdown_callback =
  953. base::BindLambdaForTesting(
  954. [&](HostResolver* resolver) { shutdown_resolver = resolver; });
  955. std::unique_ptr<net::HostResolver> inner_resolver =
  956. net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
  957. HostResolver resolver(resolver_remote.BindNewPipeAndPassReceiver(),
  958. std::move(shutdown_callback), inner_resolver.get(),
  959. net::NetLog::Get());
  960. base::RunLoop run_loop;
  961. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  962. mojom::ResolveHostParametersPtr optional_parameters =
  963. mojom::ResolveHostParameters::New();
  964. optional_parameters->control_handle =
  965. control_handle.BindNewPipeAndPassReceiver();
  966. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  967. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  968. // Resolve "localhost" because it should always resolve fast and locally, even
  969. // when using a real HostResolver.
  970. resolver_remote->ResolveHost(
  971. net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
  972. std::move(optional_parameters), std::move(pending_response_client));
  973. run_loop.Run();
  974. EXPECT_EQ(net::OK, response_client.result_error());
  975. EXPECT_THAT(
  976. response_client.result_addresses().value().endpoints(),
  977. testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 160),
  978. CreateExpectedEndPoint("::1", 160)));
  979. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  980. EXPECT_FALSE(shutdown_resolver);
  981. }
  982. TEST_F(HostResolverTest, CloseBinding) {
  983. mojo::Remote<mojom::HostResolver> resolver_remote;
  984. HostResolver* shutdown_resolver = nullptr;
  985. HostResolver::ConnectionShutdownCallback shutdown_callback =
  986. base::BindLambdaForTesting(
  987. [&](HostResolver* resolver) { shutdown_resolver = resolver; });
  988. // Use a HangingHostResolver, so the test can ensure the request won't be
  989. // completed before the cancellation arrives.
  990. auto inner_resolver = std::make_unique<net::HangingHostResolver>();
  991. HostResolver resolver(resolver_remote.BindNewPipeAndPassReceiver(),
  992. std::move(shutdown_callback), inner_resolver.get(),
  993. net::NetLog::Get());
  994. ASSERT_EQ(0, inner_resolver->num_cancellations());
  995. base::RunLoop run_loop;
  996. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  997. mojom::ResolveHostParametersPtr optional_parameters =
  998. mojom::ResolveHostParameters::New();
  999. optional_parameters->control_handle =
  1000. control_handle.BindNewPipeAndPassReceiver();
  1001. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  1002. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  1003. resolver_remote->ResolveHost(
  1004. net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
  1005. std::move(optional_parameters), std::move(pending_response_client));
  1006. bool control_handle_closed = false;
  1007. auto connection_error_callback =
  1008. base::BindLambdaForTesting([&]() { control_handle_closed = true; });
  1009. control_handle.set_disconnect_handler(connection_error_callback);
  1010. resolver_remote.reset();
  1011. run_loop.Run();
  1012. // Request should be cancelled.
  1013. EXPECT_EQ(net::ERR_FAILED, response_client.result_error());
  1014. EXPECT_FALSE(response_client.result_addresses());
  1015. EXPECT_TRUE(control_handle_closed);
  1016. EXPECT_EQ(1, inner_resolver->num_cancellations());
  1017. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  1018. // Callback should have been called.
  1019. EXPECT_EQ(&resolver, shutdown_resolver);
  1020. }
  1021. TEST_F(HostResolverTest, CloseBinding_SubsequentRequest) {
  1022. mojo::Remote<mojom::HostResolver> resolver_remote;
  1023. HostResolver* shutdown_resolver = nullptr;
  1024. HostResolver::ConnectionShutdownCallback shutdown_callback =
  1025. base::BindLambdaForTesting(
  1026. [&](HostResolver* resolver) { shutdown_resolver = resolver; });
  1027. std::unique_ptr<net::HostResolver> inner_resolver =
  1028. net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
  1029. HostResolver resolver(resolver_remote.BindNewPipeAndPassReceiver(),
  1030. std::move(shutdown_callback), inner_resolver.get(),
  1031. net::NetLog::Get());
  1032. base::RunLoop run_loop;
  1033. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  1034. TestResolveHostClient response_client(&pending_response_client, nullptr);
  1035. resolver_remote->ResolveHost(net::HostPortPair("localhost", 160),
  1036. net::NetworkIsolationKey(), nullptr,
  1037. std::move(pending_response_client));
  1038. resolver_remote.reset();
  1039. run_loop.RunUntilIdle();
  1040. // Not using a hanging resolver, so could be ERR_FAILED or OK depending on
  1041. // timing of the cancellation.
  1042. EXPECT_TRUE(response_client.result_error() == net::ERR_FAILED ||
  1043. response_client.result_error() == net::OK);
  1044. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  1045. // Callback should have been called.
  1046. EXPECT_EQ(&resolver, shutdown_resolver);
  1047. // Subsequent requests should be unaffected by the cancellation.
  1048. base::RunLoop run_loop2;
  1049. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client2;
  1050. TestResolveHostClient response_client2(&pending_response_client2, &run_loop2);
  1051. resolver.ResolveHost(net::HostPortPair("localhost", 80),
  1052. net::NetworkIsolationKey(), nullptr,
  1053. std::move(pending_response_client2));
  1054. run_loop2.Run();
  1055. EXPECT_EQ(net::OK, response_client2.result_error());
  1056. EXPECT_THAT(
  1057. response_client2.result_addresses().value().endpoints(),
  1058. testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
  1059. CreateExpectedEndPoint("::1", 80)));
  1060. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  1061. }
  1062. TEST_F(HostResolverTest, IsSpeculative) {
  1063. std::unique_ptr<net::HostResolver> inner_resolver =
  1064. net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
  1065. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  1066. base::RunLoop run_loop;
  1067. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  1068. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  1069. mojom::ResolveHostParametersPtr parameters =
  1070. mojom::ResolveHostParameters::New();
  1071. parameters->is_speculative = true;
  1072. // Resolve "localhost" because it should always resolve fast and locally, even
  1073. // when using a real HostResolver.
  1074. resolver.ResolveHost(net::HostPortPair("localhost", 80),
  1075. net::NetworkIsolationKey(), std::move(parameters),
  1076. std::move(pending_response_client));
  1077. run_loop.Run();
  1078. EXPECT_EQ(net::OK, response_client.result_error());
  1079. EXPECT_FALSE(response_client.result_addresses());
  1080. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  1081. }
  1082. net::DnsConfig CreateValidDnsConfig() {
  1083. net::IPAddress dns_ip(192, 168, 1, 0);
  1084. net::DnsConfig config;
  1085. config.nameservers.push_back(
  1086. net::IPEndPoint(dns_ip, net::dns_protocol::kDefaultPort));
  1087. EXPECT_TRUE(config.IsValid());
  1088. return config;
  1089. }
  1090. TEST_F(HostResolverTest, TextResults) {
  1091. static const char* kTextRecords[] = {"foo", "bar", "more text"};
  1092. net::MockDnsClientRuleList rules;
  1093. rules.emplace_back(
  1094. "example.com", net::dns_protocol::kTypeTXT, false /* secure */,
  1095. net::MockDnsClientRule::Result(net::BuildTestDnsTextResponse(
  1096. "example.com", {std::vector<std::string>(std::begin(kTextRecords),
  1097. std::end(kTextRecords))})),
  1098. false /* delay */);
  1099. auto dns_client = std::make_unique<net::MockDnsClient>(CreateValidDnsConfig(),
  1100. std::move(rules));
  1101. dns_client->set_ignore_system_config_changes(true);
  1102. std::unique_ptr<net::ContextHostResolver> inner_resolver =
  1103. net::HostResolver::CreateStandaloneContextResolver(net::NetLog::Get());
  1104. inner_resolver->GetManagerForTesting()->SetDnsClientForTesting(
  1105. std::move(dns_client));
  1106. inner_resolver->GetManagerForTesting()->SetInsecureDnsClientEnabled(
  1107. /*enabled=*/true,
  1108. /*additional_dns_types_enabled=*/true);
  1109. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  1110. base::RunLoop run_loop;
  1111. mojom::ResolveHostParametersPtr optional_parameters =
  1112. mojom::ResolveHostParameters::New();
  1113. optional_parameters->dns_query_type = net::DnsQueryType::TXT;
  1114. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  1115. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  1116. resolver.ResolveHost(
  1117. net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
  1118. std::move(optional_parameters), std::move(pending_response_client));
  1119. run_loop.Run();
  1120. EXPECT_EQ(net::OK, response_client.result_error());
  1121. EXPECT_FALSE(response_client.result_addresses());
  1122. EXPECT_THAT(response_client.result_text(),
  1123. testing::Optional(testing::ElementsAreArray(kTextRecords)));
  1124. EXPECT_FALSE(response_client.result_hosts());
  1125. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  1126. }
  1127. TEST_F(HostResolverTest, HostResults) {
  1128. net::MockDnsClientRuleList rules;
  1129. rules.emplace_back(
  1130. "example.com", net::dns_protocol::kTypePTR, false /*secure */,
  1131. net::MockDnsClientRule::Result(net::BuildTestDnsPointerResponse(
  1132. "example.com", {"google.com", "chromium.org"})),
  1133. false /* delay */);
  1134. auto dns_client = std::make_unique<net::MockDnsClient>(CreateValidDnsConfig(),
  1135. std::move(rules));
  1136. dns_client->set_ignore_system_config_changes(true);
  1137. std::unique_ptr<net::ContextHostResolver> inner_resolver =
  1138. net::HostResolver::CreateStandaloneContextResolver(net::NetLog::Get());
  1139. inner_resolver->GetManagerForTesting()->SetDnsClientForTesting(
  1140. std::move(dns_client));
  1141. inner_resolver->GetManagerForTesting()->SetInsecureDnsClientEnabled(
  1142. /*enabled=*/true,
  1143. /*additional_dns_types_enabled=*/true);
  1144. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  1145. base::RunLoop run_loop;
  1146. mojom::ResolveHostParametersPtr optional_parameters =
  1147. mojom::ResolveHostParameters::New();
  1148. optional_parameters->dns_query_type = net::DnsQueryType::PTR;
  1149. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  1150. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  1151. resolver.ResolveHost(
  1152. net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
  1153. std::move(optional_parameters), std::move(pending_response_client));
  1154. run_loop.Run();
  1155. EXPECT_EQ(net::OK, response_client.result_error());
  1156. EXPECT_FALSE(response_client.result_addresses());
  1157. EXPECT_FALSE(response_client.result_text());
  1158. EXPECT_THAT(response_client.result_hosts(),
  1159. testing::Optional(testing::UnorderedElementsAre(
  1160. net::HostPortPair("google.com", 160),
  1161. net::HostPortPair("chromium.org", 160))));
  1162. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  1163. }
  1164. TEST_F(HostResolverTest, RespectsDisablingAdditionalQueryTypes) {
  1165. net::MockDnsClientRuleList rules;
  1166. auto dns_client = std::make_unique<net::MockDnsClient>(CreateValidDnsConfig(),
  1167. std::move(rules));
  1168. dns_client->set_ignore_system_config_changes(true);
  1169. std::unique_ptr<net::ContextHostResolver> inner_resolver =
  1170. net::HostResolver::CreateStandaloneContextResolver(net::NetLog::Get());
  1171. inner_resolver->GetManagerForTesting()->SetDnsClientForTesting(
  1172. std::move(dns_client));
  1173. inner_resolver->GetManagerForTesting()->SetInsecureDnsClientEnabled(
  1174. /*enabled=*/true,
  1175. /*additional_dns_types_enabled=*/false);
  1176. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  1177. base::RunLoop run_loop;
  1178. mojom::ResolveHostParametersPtr optional_parameters =
  1179. mojom::ResolveHostParameters::New();
  1180. optional_parameters->dns_query_type = net::DnsQueryType::PTR;
  1181. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  1182. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  1183. resolver.ResolveHost(
  1184. net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
  1185. std::move(optional_parameters), std::move(pending_response_client));
  1186. run_loop.Run();
  1187. // No queries made, so result is `ERR_DNS_CACHE_MISS`.
  1188. EXPECT_THAT(response_client.result_error(),
  1189. net::test::IsError(net::ERR_DNS_CACHE_MISS));
  1190. EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
  1191. }
  1192. #if BUILDFLAG(ENABLE_MDNS)
  1193. TEST_F(HostResolverTest, MdnsListener_AddressResult) {
  1194. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  1195. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  1196. mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
  1197. TestMdnsListenClient response_client(&pending_response_client);
  1198. int error = net::ERR_FAILED;
  1199. base::RunLoop run_loop;
  1200. net::HostPortPair host("host.local", 41);
  1201. resolver.MdnsListen(host, net::DnsQueryType::A,
  1202. std::move(pending_response_client),
  1203. base::BindLambdaForTesting([&](int error_val) {
  1204. error = error_val;
  1205. run_loop.Quit();
  1206. }));
  1207. run_loop.Run();
  1208. ASSERT_EQ(net::OK, error);
  1209. net::IPAddress result_address(1, 2, 3, 4);
  1210. net::IPEndPoint result(result_address, 41);
  1211. inner_resolver->TriggerMdnsListeners(
  1212. host, net::DnsQueryType::A, net::MdnsListenerUpdateType::kAdded, result);
  1213. base::RunLoop().RunUntilIdle();
  1214. EXPECT_THAT(
  1215. response_client.address_results(),
  1216. testing::ElementsAre(TestMdnsListenClient::CreateExpectedResult(
  1217. net::MdnsListenerUpdateType::kAdded, net::DnsQueryType::A, result)));
  1218. EXPECT_THAT(response_client.text_results(), testing::IsEmpty());
  1219. EXPECT_THAT(response_client.hostname_results(), testing::IsEmpty());
  1220. EXPECT_THAT(response_client.unhandled_results(), testing::IsEmpty());
  1221. }
  1222. TEST_F(HostResolverTest, MdnsListener_TextResult) {
  1223. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  1224. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  1225. mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
  1226. TestMdnsListenClient response_client(&pending_response_client);
  1227. int error = net::ERR_FAILED;
  1228. base::RunLoop run_loop;
  1229. net::HostPortPair host("host.local", 42);
  1230. resolver.MdnsListen(host, net::DnsQueryType::TXT,
  1231. std::move(pending_response_client),
  1232. base::BindLambdaForTesting([&](int error_val) {
  1233. error = error_val;
  1234. run_loop.Quit();
  1235. }));
  1236. run_loop.Run();
  1237. ASSERT_EQ(net::OK, error);
  1238. inner_resolver->TriggerMdnsListeners(host, net::DnsQueryType::TXT,
  1239. net::MdnsListenerUpdateType::kChanged,
  1240. {"foo", "bar"});
  1241. base::RunLoop().RunUntilIdle();
  1242. EXPECT_THAT(
  1243. response_client.text_results(),
  1244. testing::UnorderedElementsAre(TestMdnsListenClient::CreateExpectedResult(
  1245. net::MdnsListenerUpdateType::kChanged,
  1246. net::DnsQueryType::TXT, "foo"),
  1247. TestMdnsListenClient::CreateExpectedResult(
  1248. net::MdnsListenerUpdateType::kChanged,
  1249. net::DnsQueryType::TXT, "bar")));
  1250. EXPECT_THAT(response_client.address_results(), testing::IsEmpty());
  1251. EXPECT_THAT(response_client.hostname_results(), testing::IsEmpty());
  1252. EXPECT_THAT(response_client.unhandled_results(), testing::IsEmpty());
  1253. }
  1254. TEST_F(HostResolverTest, MdnsListener_HostnameResult) {
  1255. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  1256. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  1257. mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
  1258. TestMdnsListenClient response_client(&pending_response_client);
  1259. int error = net::ERR_FAILED;
  1260. base::RunLoop run_loop;
  1261. net::HostPortPair host("host.local", 43);
  1262. resolver.MdnsListen(host, net::DnsQueryType::PTR,
  1263. std::move(pending_response_client),
  1264. base::BindLambdaForTesting([&](int error_val) {
  1265. error = error_val;
  1266. run_loop.Quit();
  1267. }));
  1268. run_loop.Run();
  1269. ASSERT_EQ(net::OK, error);
  1270. net::HostPortPair result("example.com", 43);
  1271. inner_resolver->TriggerMdnsListeners(host, net::DnsQueryType::PTR,
  1272. net::MdnsListenerUpdateType::kRemoved,
  1273. result);
  1274. base::RunLoop().RunUntilIdle();
  1275. EXPECT_THAT(response_client.hostname_results(),
  1276. testing::ElementsAre(TestMdnsListenClient::CreateExpectedResult(
  1277. net::MdnsListenerUpdateType::kRemoved, net::DnsQueryType::PTR,
  1278. result)));
  1279. EXPECT_THAT(response_client.address_results(), testing::IsEmpty());
  1280. EXPECT_THAT(response_client.text_results(), testing::IsEmpty());
  1281. EXPECT_THAT(response_client.unhandled_results(), testing::IsEmpty());
  1282. }
  1283. TEST_F(HostResolverTest, MdnsListener_UnhandledResult) {
  1284. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  1285. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  1286. mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
  1287. TestMdnsListenClient response_client(&pending_response_client);
  1288. int error = net::ERR_FAILED;
  1289. base::RunLoop run_loop;
  1290. net::HostPortPair host("host.local", 44);
  1291. resolver.MdnsListen(host, net::DnsQueryType::PTR,
  1292. std::move(pending_response_client),
  1293. base::BindLambdaForTesting([&](int error_val) {
  1294. error = error_val;
  1295. run_loop.Quit();
  1296. }));
  1297. run_loop.Run();
  1298. ASSERT_EQ(net::OK, error);
  1299. inner_resolver->TriggerMdnsListeners(host, net::DnsQueryType::PTR,
  1300. net::MdnsListenerUpdateType::kAdded);
  1301. base::RunLoop().RunUntilIdle();
  1302. EXPECT_THAT(
  1303. response_client.unhandled_results(),
  1304. testing::ElementsAre(std::make_pair(net::MdnsListenerUpdateType::kAdded,
  1305. net::DnsQueryType::PTR)));
  1306. EXPECT_THAT(response_client.address_results(), testing::IsEmpty());
  1307. EXPECT_THAT(response_client.text_results(), testing::IsEmpty());
  1308. EXPECT_THAT(response_client.hostname_results(), testing::IsEmpty());
  1309. }
  1310. #endif // BUILDFLAG(ENABLE_MDNS)
  1311. #if BUILDFLAG(IS_ANDROID)
  1312. class HostResolverRecordRadioWakeupTest : public HostResolverTest {
  1313. public:
  1314. HostResolverRecordRadioWakeupTest() {
  1315. scoped_feature_list_.InitAndEnableFeature(
  1316. net::features::kRecordRadioWakeupTrigger);
  1317. }
  1318. private:
  1319. base::test::ScopedFeatureList scoped_feature_list_;
  1320. };
  1321. TEST_F(HostResolverRecordRadioWakeupTest, RecordPreconnect) {
  1322. base::HistogramTester histograms;
  1323. net::android::RadioActivityTracker::GetInstance()
  1324. .OverrideRadioActivityForTesting(
  1325. base::android::RadioDataActivity::kDormant);
  1326. net::android::RadioActivityTracker::GetInstance().OverrideRadioTypeForTesting(
  1327. base::android::RadioConnectionType::kCell);
  1328. auto inner_resolver = std::make_unique<net::MockHostResolver>();
  1329. inner_resolver->set_synchronous_mode(false);
  1330. inner_resolver->rules()->AddRule("example.com", "1.2.3.4");
  1331. HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
  1332. base::RunLoop run_loop;
  1333. mojo::Remote<mojom::ResolveHostHandle> control_handle;
  1334. mojom::ResolveHostParametersPtr optional_parameters =
  1335. mojom::ResolveHostParameters::New();
  1336. optional_parameters->control_handle =
  1337. control_handle.BindNewPipeAndPassReceiver();
  1338. optional_parameters->purpose =
  1339. mojom::ResolveHostParameters::Purpose::kPreconnect;
  1340. mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
  1341. TestResolveHostClient response_client(&pending_response_client, &run_loop);
  1342. resolver.ResolveHost(
  1343. net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
  1344. std::move(optional_parameters), std::move(pending_response_client));
  1345. run_loop.Run();
  1346. EXPECT_EQ(net::OK, response_client.result_error());
  1347. histograms.ExpectUniqueSample(
  1348. kUmaNamePossibleWakeupTriggerResolveHost,
  1349. mojom::ResolveHostParameters::Purpose::kPreconnect, 1);
  1350. }
  1351. #endif // BUILDFLAG(IS_ANDROID)
  1352. } // namespace
  1353. } // namespace network