12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631 |
- // Copyright 2018 The Chromium Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style license that can be
- // found in the LICENSE file.
- #include "services/network/host_resolver.h"
- #include <map>
- #include <utility>
- #include <vector>
- #include "base/check.h"
- #include "base/memory/raw_ptr.h"
- #include "base/run_loop.h"
- #include "base/test/bind.h"
- #include "base/test/task_environment.h"
- #include "base/time/time.h"
- #include "build/build_config.h"
- #include "mojo/public/cpp/bindings/pending_remote.h"
- #include "mojo/public/cpp/bindings/receiver.h"
- #include "mojo/public/cpp/bindings/remote.h"
- #include "net/base/address_list.h"
- #include "net/base/host_port_pair.h"
- #include "net/base/ip_address.h"
- #include "net/base/ip_endpoint.h"
- #include "net/base/net_errors.h"
- #include "net/base/network_isolation_key.h"
- #include "net/dns/context_host_resolver.h"
- #include "net/dns/dns_config.h"
- #include "net/dns/dns_test_util.h"
- #include "net/dns/host_resolver.h"
- #include "net/dns/host_resolver_manager.h"
- #include "net/dns/mock_host_resolver.h"
- #include "net/dns/public/dns_protocol.h"
- #include "net/dns/public/host_resolver_source.h"
- #include "net/dns/public/mdns_listener_update_type.h"
- #include "net/dns/public/secure_dns_policy.h"
- #include "net/log/net_log.h"
- #include "net/net_buildflags.h"
- #include "net/test/gtest_util.h"
- #include "testing/gmock/include/gmock/gmock.h"
- #include "testing/gtest/include/gtest/gtest.h"
- #include "third_party/abseil-cpp/absl/types/optional.h"
- #if BUILDFLAG(IS_ANDROID)
- #include "base/android/radio_utils.h"
- #include "base/test/metrics/histogram_tester.h"
- #include "base/test/scoped_feature_list.h"
- #include "net/android/radio_activity_tracker.h"
- #include "net/base/features.h"
- #include "services/network/radio_monitor_android.h"
- #endif
- namespace network {
- namespace {
- class HostResolverTest : public testing::Test {
- public:
- HostResolverTest() = default;
- protected:
- base::test::TaskEnvironment task_environment_{
- base::test::TaskEnvironment::TimeSource::MOCK_TIME,
- base::test::TaskEnvironment::MainThreadType::IO};
- };
- net::IPEndPoint CreateExpectedEndPoint(const std::string& address,
- uint16_t port) {
- net::IPAddress ip_address;
- CHECK(ip_address.AssignFromIPLiteral(address));
- return net::IPEndPoint(ip_address, port);
- }
- class TestResolveHostClient : public mojom::ResolveHostClient {
- public:
- // If |run_loop| is non-null, will call RunLoop::Quit() on completion.
- TestResolveHostClient(mojo::PendingRemote<mojom::ResolveHostClient>* remote,
- base::RunLoop* run_loop)
- : receiver_(this, remote->InitWithNewPipeAndPassReceiver()),
- complete_(false),
- top_level_result_error_(net::ERR_IO_PENDING),
- result_error_(net::ERR_UNEXPECTED),
- run_loop_(run_loop) {}
- void CloseReceiver() { receiver_.reset(); }
- void OnComplete(int error,
- const net::ResolveErrorInfo& resolve_error_info,
- const absl::optional<net::AddressList>& addresses) override {
- DCHECK(!complete_);
- complete_ = true;
- top_level_result_error_ = error;
- result_error_ = resolve_error_info.error;
- result_addresses_ = addresses;
- if (run_loop_)
- run_loop_->Quit();
- }
- void OnTextResults(const std::vector<std::string>& text_results) override {
- DCHECK(!complete_);
- result_text_ = text_results;
- }
- void OnHostnameResults(const std::vector<net::HostPortPair>& hosts) override {
- DCHECK(!complete_);
- result_hosts_ = hosts;
- }
- bool complete() const { return complete_; }
- int top_level_result_error() const {
- DCHECK(complete_);
- return top_level_result_error_;
- }
- int result_error() const {
- DCHECK(complete_);
- return result_error_;
- }
- const absl::optional<net::AddressList>& result_addresses() const {
- DCHECK(complete_);
- return result_addresses_;
- }
- const absl::optional<std::vector<std::string>>& result_text() const {
- DCHECK(complete_);
- return result_text_;
- }
- const absl::optional<std::vector<net::HostPortPair>>& result_hosts() const {
- DCHECK(complete_);
- return result_hosts_;
- }
- private:
- mojo::Receiver<mojom::ResolveHostClient> receiver_{this};
- bool complete_;
- int top_level_result_error_;
- int result_error_;
- absl::optional<net::AddressList> result_addresses_;
- absl::optional<std::vector<std::string>> result_text_;
- absl::optional<std::vector<net::HostPortPair>> result_hosts_;
- const raw_ptr<base::RunLoop> run_loop_;
- };
- class TestMdnsListenClient : public mojom::MdnsListenClient {
- public:
- using UpdateType = net::MdnsListenerUpdateType;
- using UpdateKey = std::pair<UpdateType, net::DnsQueryType>;
- explicit TestMdnsListenClient(
- mojo::PendingRemote<mojom::MdnsListenClient>* remote)
- : receiver_(this, remote->InitWithNewPipeAndPassReceiver()) {}
- void OnAddressResult(UpdateType update_type,
- net::DnsQueryType result_type,
- const net::IPEndPoint& address) override {
- address_results_.insert({{update_type, result_type}, address});
- }
- void OnTextResult(UpdateType update_type,
- net::DnsQueryType result_type,
- const std::vector<std::string>& text_records) override {
- for (auto& text_record : text_records) {
- text_results_.insert({{update_type, result_type}, text_record});
- }
- }
- void OnHostnameResult(UpdateType update_type,
- net::DnsQueryType result_type,
- const net::HostPortPair& host) override {
- hostname_results_.insert({{update_type, result_type}, host});
- }
- void OnUnhandledResult(UpdateType update_type,
- net::DnsQueryType result_type) override {
- unhandled_results_.insert({update_type, result_type});
- }
- const std::multimap<UpdateKey, net::IPEndPoint>& address_results() {
- return address_results_;
- }
- const std::multimap<UpdateKey, std::string>& text_results() {
- return text_results_;
- }
- const std::multimap<UpdateKey, net::HostPortPair>& hostname_results() {
- return hostname_results_;
- }
- const std::multiset<UpdateKey>& unhandled_results() {
- return unhandled_results_;
- }
- template <typename T>
- static std::pair<UpdateKey, T> CreateExpectedResult(
- UpdateType update_type,
- net::DnsQueryType query_type,
- T result) {
- return std::make_pair(std::make_pair(update_type, query_type), result);
- }
- private:
- mojo::Receiver<mojom::MdnsListenClient> receiver_;
- std::multimap<UpdateKey, net::IPEndPoint> address_results_;
- std::multimap<UpdateKey, std::string> text_results_;
- std::multimap<UpdateKey, net::HostPortPair> hostname_results_;
- std::multiset<UpdateKey> unhandled_results_;
- };
- TEST_F(HostResolverTest, Sync) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- inner_resolver->set_synchronous_mode(true);
- inner_resolver->rules()->AddRule("example.test", "1.2.3.4");
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("example.test", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.top_level_result_error());
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(response_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
- EXPECT_FALSE(response_client.result_text());
- EXPECT_FALSE(response_client.result_hosts());
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- EXPECT_EQ(net::DEFAULT_PRIORITY, inner_resolver->last_request_priority());
- }
- TEST_F(HostResolverTest, Async) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- inner_resolver->set_synchronous_mode(false);
- inner_resolver->rules()->AddRule("example.test", "1.2.3.4");
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("example.test", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- bool control_handle_closed = false;
- auto connection_error_callback =
- base::BindLambdaForTesting([&]() { control_handle_closed = true; });
- control_handle.set_disconnect_handler(connection_error_callback);
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(response_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
- EXPECT_FALSE(response_client.result_text());
- EXPECT_FALSE(response_client.result_hosts());
- EXPECT_TRUE(control_handle_closed);
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- EXPECT_EQ(net::DEFAULT_PRIORITY, inner_resolver->last_request_priority());
- }
- TEST_F(HostResolverTest, DnsQueryType) {
- std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->dns_query_type = net::DnsQueryType::AAAA;
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(response_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint("::1", 160)));
- }
- TEST_F(HostResolverTest, InitialPriority) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- inner_resolver->rules()->AddRule("priority.test", "1.2.3.4");
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->initial_priority = net::HIGHEST;
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("priority.test", 80), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(response_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 80)));
- EXPECT_EQ(net::HIGHEST, inner_resolver->last_request_priority());
- }
- // Make requests specifying a source for host resolution and ensure the correct
- // source is requested from the inner resolver.
- TEST_F(HostResolverTest, Source) {
- constexpr char kDomain[] = "example.com";
- constexpr char kAnyResult[] = "1.2.3.4";
- constexpr char kSystemResult[] = "127.0.0.1";
- constexpr char kDnsResult[] = "168.100.12.23";
- constexpr char kMdnsResult[] = "200.1.2.3";
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- net::MockHostResolverBase::RuleResolver::RuleKey any_key;
- any_key.hostname_pattern = kDomain;
- any_key.query_source = net::HostResolverSource::ANY;
- inner_resolver->rules()->AddRule(std::move(any_key), kAnyResult);
- net::MockHostResolverBase::RuleResolver::RuleKey system_key;
- system_key.hostname_pattern = kDomain;
- system_key.query_source = net::HostResolverSource::SYSTEM;
- inner_resolver->rules()->AddRule(std::move(system_key), kSystemResult);
- net::MockHostResolverBase::RuleResolver::RuleKey dns_key;
- dns_key.hostname_pattern = kDomain;
- dns_key.query_source = net::HostResolverSource::DNS;
- inner_resolver->rules()->AddRule(std::move(dns_key), kDnsResult);
- net::MockHostResolverBase::RuleResolver::RuleKey mdns_key;
- mdns_key.hostname_pattern = kDomain;
- mdns_key.query_source = net::HostResolverSource::MULTICAST_DNS;
- inner_resolver->rules()->AddRule(std::move(mdns_key), kMdnsResult);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop any_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_any_client;
- TestResolveHostClient any_client(&pending_any_client, &any_run_loop);
- mojom::ResolveHostParametersPtr any_parameters =
- mojom::ResolveHostParameters::New();
- any_parameters->source = net::HostResolverSource::ANY;
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), std::move(any_parameters),
- std::move(pending_any_client));
- base::RunLoop system_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_system_client;
- TestResolveHostClient system_client(&pending_system_client, &system_run_loop);
- mojom::ResolveHostParametersPtr system_parameters =
- mojom::ResolveHostParameters::New();
- system_parameters->source = net::HostResolverSource::SYSTEM;
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), std::move(system_parameters),
- std::move(pending_system_client));
- base::RunLoop dns_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_dns_client;
- TestResolveHostClient dns_client(&pending_dns_client, &dns_run_loop);
- mojom::ResolveHostParametersPtr dns_parameters =
- mojom::ResolveHostParameters::New();
- dns_parameters->source = net::HostResolverSource::DNS;
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), std::move(dns_parameters),
- std::move(pending_dns_client));
- any_run_loop.Run();
- system_run_loop.Run();
- dns_run_loop.Run();
- EXPECT_EQ(net::OK, any_client.result_error());
- EXPECT_THAT(any_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kAnyResult, 80)));
- EXPECT_EQ(net::OK, system_client.result_error());
- EXPECT_THAT(system_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kSystemResult, 80)));
- EXPECT_EQ(net::OK, dns_client.result_error());
- EXPECT_THAT(dns_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kDnsResult, 80)));
- #if BUILDFLAG(ENABLE_MDNS)
- base::RunLoop mdns_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_mdns_client;
- TestResolveHostClient mdns_client(&pending_mdns_client, &mdns_run_loop);
- mojom::ResolveHostParametersPtr mdns_parameters =
- mojom::ResolveHostParameters::New();
- mdns_parameters->source = net::HostResolverSource::MULTICAST_DNS;
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), std::move(mdns_parameters),
- std::move(pending_mdns_client));
- mdns_run_loop.Run();
- EXPECT_EQ(net::OK, mdns_client.result_error());
- EXPECT_THAT(mdns_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kMdnsResult, 80)));
- #endif // BUILDFLAG(ENABLE_MDNS)
- }
- // Test that cached results are properly keyed by requested source.
- TEST_F(HostResolverTest, SeparateCacheBySource) {
- constexpr char kDomain[] = "example.com";
- constexpr char kAnyResultOriginal[] = "1.2.3.4";
- constexpr char kSystemResultOriginal[] = "127.0.0.1";
- auto inner_resolver = std::make_unique<net::MockCachingHostResolver>();
- net::MockHostResolverBase::RuleResolver::RuleKey any_key;
- any_key.hostname_pattern = kDomain;
- any_key.query_source = net::HostResolverSource::ANY;
- inner_resolver->rules()->AddRule(any_key, kAnyResultOriginal);
- net::MockHostResolverBase::RuleResolver::RuleKey system_key;
- system_key.hostname_pattern = kDomain;
- system_key.query_source = net::HostResolverSource::SYSTEM;
- inner_resolver->rules()->AddRule(system_key, kSystemResultOriginal);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- // Load SYSTEM result into cache.
- base::RunLoop system_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_system_client_ptr;
- TestResolveHostClient system_client(&pending_system_client_ptr,
- &system_run_loop);
- mojom::ResolveHostParametersPtr system_parameters =
- mojom::ResolveHostParameters::New();
- system_parameters->source = net::HostResolverSource::SYSTEM;
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), std::move(system_parameters),
- std::move(pending_system_client_ptr));
- system_run_loop.Run();
- ASSERT_EQ(net::OK, system_client.result_error());
- EXPECT_THAT(
- system_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kSystemResultOriginal, 80)));
- // Change |inner_resolver| rules to ensure results are coming from cache or
- // not based on whether they resolve to the old or new value.
- constexpr char kAnyResultFresh[] = "111.222.1.1";
- constexpr char kSystemResultFresh[] = "111.222.1.2";
- inner_resolver->rules()->ClearRules();
- inner_resolver->rules()->AddRule(any_key, kAnyResultFresh);
- inner_resolver->rules()->AddRule(system_key, kSystemResultFresh);
- base::RunLoop cached_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_cached_client;
- TestResolveHostClient cached_client(&pending_cached_client, &cached_run_loop);
- mojom::ResolveHostParametersPtr cached_parameters =
- mojom::ResolveHostParameters::New();
- cached_parameters->source = net::HostResolverSource::SYSTEM;
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), std::move(cached_parameters),
- std::move(pending_cached_client));
- base::RunLoop uncached_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_uncached_client;
- TestResolveHostClient uncached_client(&pending_uncached_client,
- &uncached_run_loop);
- mojom::ResolveHostParametersPtr uncached_parameters =
- mojom::ResolveHostParameters::New();
- uncached_parameters->source = net::HostResolverSource::ANY;
- resolver.ResolveHost(
- net::HostPortPair(kDomain, 80), net::NetworkIsolationKey(),
- std::move(uncached_parameters), std::move(pending_uncached_client));
- cached_run_loop.Run();
- uncached_run_loop.Run();
- EXPECT_EQ(net::OK, cached_client.result_error());
- EXPECT_THAT(
- cached_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kSystemResultOriginal, 80)));
- EXPECT_EQ(net::OK, uncached_client.result_error());
- EXPECT_THAT(
- uncached_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kAnyResultFresh, 80)));
- }
- TEST_F(HostResolverTest, CacheDisabled) {
- constexpr char kDomain[] = "example.com";
- constexpr char kResultOriginal[] = "1.2.3.4";
- auto inner_resolver = std::make_unique<net::MockCachingHostResolver>();
- inner_resolver->rules()->AddRule(kDomain, kResultOriginal);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- // Load result into cache.
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_client;
- TestResolveHostClient client(&pending_client, &run_loop);
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), nullptr,
- std::move(pending_client));
- run_loop.Run();
- ASSERT_EQ(net::OK, client.result_error());
- EXPECT_THAT(
- client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kResultOriginal, 80)));
- // Change |inner_resolver| rules to ensure results are coming from cache or
- // not based on whether they resolve to the old or new value.
- constexpr char kResultFresh[] = "111.222.1.1";
- inner_resolver->rules()->ClearRules();
- inner_resolver->rules()->AddRule(kDomain, kResultFresh);
- base::RunLoop cached_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_cached_client;
- TestResolveHostClient cached_client(&pending_cached_client, &cached_run_loop);
- mojom::ResolveHostParametersPtr cached_parameters =
- mojom::ResolveHostParameters::New();
- cached_parameters->cache_usage =
- mojom::ResolveHostParameters::CacheUsage::ALLOWED;
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), std::move(cached_parameters),
- std::move(pending_cached_client));
- cached_run_loop.Run();
- EXPECT_EQ(net::OK, cached_client.result_error());
- EXPECT_THAT(
- cached_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kResultOriginal, 80)));
- base::RunLoop uncached_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_uncached_client;
- TestResolveHostClient uncached_client(&pending_uncached_client,
- &uncached_run_loop);
- mojom::ResolveHostParametersPtr uncached_parameters =
- mojom::ResolveHostParameters::New();
- uncached_parameters->cache_usage =
- mojom::ResolveHostParameters::CacheUsage::DISALLOWED;
- resolver.ResolveHost(
- net::HostPortPair(kDomain, 80), net::NetworkIsolationKey(),
- std::move(uncached_parameters), std::move(pending_uncached_client));
- uncached_run_loop.Run();
- EXPECT_EQ(net::OK, uncached_client.result_error());
- EXPECT_THAT(uncached_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kResultFresh, 80)));
- }
- TEST_F(HostResolverTest, CacheStaleAllowed) {
- constexpr char kDomain[] = "example.com";
- constexpr char kResultOriginal[] = "1.2.3.4";
- auto inner_resolver = std::make_unique<net::MockCachingHostResolver>();
- inner_resolver->rules()->AddRule(kDomain, kResultOriginal);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- // Load result into cache.
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_client;
- TestResolveHostClient client(&pending_client, &run_loop);
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), nullptr,
- std::move(pending_client));
- run_loop.Run();
- ASSERT_EQ(net::OK, client.result_error());
- EXPECT_THAT(
- client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kResultOriginal, 80)));
- // Change |inner_resolver| rules to ensure results are coming from cache or
- // not based on whether they resolve to the old or new value.
- constexpr char kResultFresh[] = "111.222.1.1";
- inner_resolver->rules()->ClearRules();
- inner_resolver->rules()->AddRule(kDomain, kResultFresh);
- // MockHostResolver gives cache entries a 1 min TTL, so simulate a day
- // passing, which is more than long enough for the cached results to become
- // stale.
- task_environment_.FastForwardBy(base::Days(1));
- // Fetching stale results returns the original cached value.
- base::RunLoop cached_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_cached_client;
- TestResolveHostClient cached_client(&pending_cached_client, &cached_run_loop);
- mojom::ResolveHostParametersPtr cached_parameters =
- mojom::ResolveHostParameters::New();
- cached_parameters->cache_usage =
- mojom::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), std::move(cached_parameters),
- std::move(pending_cached_client));
- cached_run_loop.Run();
- EXPECT_EQ(net::OK, cached_client.result_error());
- EXPECT_THAT(
- cached_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kResultOriginal, 80)));
- // Resolution where only non-stale cache usage is allowed returns the new
- // value.
- base::RunLoop uncached_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_uncached_client;
- TestResolveHostClient uncached_client(&pending_uncached_client,
- &uncached_run_loop);
- mojom::ResolveHostParametersPtr uncached_parameters =
- mojom::ResolveHostParameters::New();
- uncached_parameters->cache_usage =
- mojom::ResolveHostParameters::CacheUsage::ALLOWED;
- resolver.ResolveHost(
- net::HostPortPair(kDomain, 80), net::NetworkIsolationKey(),
- std::move(uncached_parameters), std::move(pending_uncached_client));
- uncached_run_loop.Run();
- EXPECT_EQ(net::OK, uncached_client.result_error());
- EXPECT_THAT(uncached_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint(kResultFresh, 80)));
- }
- // Test for a resolve with a result only in the cache and error if the cache is
- // disabled.
- TEST_F(HostResolverTest, CacheDisabled_ErrorResults) {
- constexpr char kDomain[] = "example.com";
- constexpr char kResult[] = "1.2.3.4";
- auto inner_resolver = std::make_unique<net::MockCachingHostResolver>();
- inner_resolver->rules()->AddRule(kDomain, kResult);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- // Load initial result into cache.
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_client;
- TestResolveHostClient client(&pending_client, &run_loop);
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), nullptr,
- std::move(pending_client));
- run_loop.Run();
- ASSERT_EQ(net::OK, client.result_error());
- // Change |inner_resolver| rules to an error.
- inner_resolver->rules()->ClearRules();
- inner_resolver->rules()->AddSimulatedFailure(kDomain);
- // Resolves for |kFreshErrorDomain| should result in error only when cache is
- // disabled because success was cached.
- base::RunLoop cached_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_cached_client;
- TestResolveHostClient cached_client(&pending_cached_client, &cached_run_loop);
- mojom::ResolveHostParametersPtr cached_parameters =
- mojom::ResolveHostParameters::New();
- cached_parameters->cache_usage =
- mojom::ResolveHostParameters::CacheUsage::ALLOWED;
- resolver.ResolveHost(net::HostPortPair(kDomain, 80),
- net::NetworkIsolationKey(), std::move(cached_parameters),
- std::move(pending_cached_client));
- cached_run_loop.Run();
- EXPECT_EQ(net::OK, cached_client.result_error());
- base::RunLoop uncached_run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_uncached_client;
- TestResolveHostClient uncached_client(&pending_uncached_client,
- &uncached_run_loop);
- mojom::ResolveHostParametersPtr uncached_parameters =
- mojom::ResolveHostParameters::New();
- uncached_parameters->cache_usage =
- mojom::ResolveHostParameters::CacheUsage::DISALLOWED;
- resolver.ResolveHost(
- net::HostPortPair(kDomain, 80), net::NetworkIsolationKey(),
- std::move(uncached_parameters), std::move(pending_uncached_client));
- uncached_run_loop.Run();
- EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, uncached_client.result_error());
- }
- TEST_F(HostResolverTest, IncludeCanonicalName) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- inner_resolver->rules()->AddRuleWithFlags("example.com", "123.0.12.24",
- net::HOST_RESOLVER_CANONNAME,
- {"canonicalexample.com"});
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->include_canonical_name = true;
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("example.com", 80), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(response_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint("123.0.12.24", 80)));
- EXPECT_THAT(response_client.result_addresses().value().dns_aliases(),
- testing::ElementsAre("canonicalexample.com"));
- }
- TEST_F(HostResolverTest, LoopbackOnly) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- inner_resolver->rules()->AddRuleWithFlags("example.com", "127.0.12.24",
- net::HOST_RESOLVER_LOOPBACK_ONLY);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->loopback_only = true;
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("example.com", 80), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(response_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint("127.0.12.24", 80)));
- }
- TEST_F(HostResolverTest, HandlesSecureDnsPolicyParameter) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- inner_resolver->rules()->AddRule("secure.test", "1.2.3.4");
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->secure_dns_policy =
- network::mojom::SecureDnsPolicy::DISABLE;
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("secure.test", 80), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(response_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 80)));
- EXPECT_EQ(net::SecureDnsPolicy::kDisable,
- inner_resolver->last_secure_dns_policy());
- }
- TEST_F(HostResolverTest, Failure_Sync) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- inner_resolver->rules()->AddSimulatedFailure("example.com");
- inner_resolver->set_synchronous_mode(true);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED,
- response_client.top_level_result_error());
- EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, response_client.result_error());
- EXPECT_FALSE(response_client.result_addresses());
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, Failure_Async) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- inner_resolver->rules()->AddSimulatedFailure("example.com");
- inner_resolver->set_synchronous_mode(false);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- bool control_handle_closed = false;
- auto connection_error_callback =
- base::BindLambdaForTesting([&]() { control_handle_closed = true; });
- control_handle.set_disconnect_handler(connection_error_callback);
- run_loop.Run();
- EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, response_client.result_error());
- EXPECT_FALSE(response_client.result_addresses());
- EXPECT_TRUE(control_handle_closed);
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, NetworkIsolationKey) {
- const url::Origin kOrigin = url::Origin::Create(GURL("https://foo.test/"));
- const net::NetworkIsolationKey kNetworkIsolationKey(kOrigin, kOrigin);
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- inner_resolver->rules()->AddRule("nik.test", "1.2.3.4");
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(net::HostPortPair("nik.test", 160), kNetworkIsolationKey,
- std::move(optional_parameters),
- std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(response_client.result_addresses().value().endpoints(),
- testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- EXPECT_EQ(kNetworkIsolationKey,
- inner_resolver->last_request_network_isolation_key());
- }
- TEST_F(HostResolverTest, NoOptionalParameters) {
- std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- // Resolve "localhost" because it should always resolve fast and locally, even
- // when using a real HostResolver.
- resolver.ResolveHost(net::HostPortPair("localhost", 80),
- net::NetworkIsolationKey(), nullptr,
- std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(
- response_client.result_addresses().value().endpoints(),
- testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
- CreateExpectedEndPoint("::1", 80)));
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, NoControlHandle) {
- std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- // Resolve "localhost" because it should always resolve fast and locally, even
- // when using a real HostResolver.
- resolver.ResolveHost(
- net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(
- response_client.result_addresses().value().endpoints(),
- testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
- CreateExpectedEndPoint("::1", 80)));
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, CloseControlHandle) {
- std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- // Resolve "localhost" because it should always resolve fast and locally, even
- // when using a real HostResolver.
- resolver.ResolveHost(
- net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- control_handle.reset();
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(
- response_client.result_addresses().value().endpoints(),
- testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 160),
- CreateExpectedEndPoint("::1", 160)));
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, Cancellation) {
- // Use a HangingHostResolver, so the test can ensure the request won't be
- // completed before the cancellation arrives.
- auto inner_resolver = std::make_unique<net::HangingHostResolver>();
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- ASSERT_EQ(0, inner_resolver->num_cancellations());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- bool control_handle_closed = false;
- auto connection_error_callback =
- base::BindLambdaForTesting([&]() { control_handle_closed = true; });
- control_handle.set_disconnect_handler(connection_error_callback);
- control_handle->Cancel(net::ERR_ABORTED);
- run_loop.Run();
- // On cancellation, should receive an ERR_FAILED result, and the internal
- // resolver request should have been cancelled.
- EXPECT_EQ(net::ERR_ABORTED, response_client.result_error());
- EXPECT_FALSE(response_client.result_addresses());
- EXPECT_EQ(1, inner_resolver->num_cancellations());
- EXPECT_TRUE(control_handle_closed);
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, Cancellation_SubsequentRequest) {
- std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, nullptr);
- resolver.ResolveHost(
- net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- control_handle->Cancel(net::ERR_ABORTED);
- run_loop.RunUntilIdle();
- // Not using a hanging resolver, so could be ERR_ABORTED or OK depending on
- // timing of the cancellation.
- EXPECT_TRUE(response_client.result_error() == net::ERR_ABORTED ||
- response_client.result_error() == net::OK);
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- // Subsequent requests should be unaffected by the cancellation.
- base::RunLoop run_loop2;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client2;
- TestResolveHostClient response_client2(&pending_response_client2, &run_loop2);
- resolver.ResolveHost(net::HostPortPair("localhost", 80),
- net::NetworkIsolationKey(), nullptr,
- std::move(pending_response_client2));
- run_loop2.Run();
- EXPECT_EQ(net::OK, response_client2.result_error());
- EXPECT_THAT(
- response_client2.result_addresses().value().endpoints(),
- testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
- CreateExpectedEndPoint("::1", 80)));
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, DestroyResolver) {
- // Use a HangingHostResolver, so the test can ensure the request won't be
- // completed before the cancellation arrives.
- auto inner_resolver = std::make_unique<net::HangingHostResolver>();
- auto resolver =
- std::make_unique<HostResolver>(inner_resolver.get(), net::NetLog::Get());
- ASSERT_EQ(0, inner_resolver->num_cancellations());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver->ResolveHost(
- net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- bool control_handle_closed = false;
- auto connection_error_callback =
- base::BindLambdaForTesting([&]() { control_handle_closed = true; });
- control_handle.set_disconnect_handler(connection_error_callback);
- resolver = nullptr;
- run_loop.Run();
- // On context destruction, should receive an ERR_FAILED result, and the
- // internal resolver request should have been cancelled.
- EXPECT_EQ(net::ERR_FAILED, response_client.result_error());
- EXPECT_FALSE(response_client.result_addresses());
- EXPECT_EQ(1, inner_resolver->num_cancellations());
- EXPECT_TRUE(control_handle_closed);
- }
- TEST_F(HostResolverTest, CloseClient) {
- // Use a HangingHostResolver, so the test can ensure the request won't be
- // completed before the cancellation arrives.
- auto inner_resolver = std::make_unique<net::HangingHostResolver>();
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- ASSERT_EQ(0, inner_resolver->num_cancellations());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- bool control_handle_closed = false;
- auto connection_error_callback =
- base::BindLambdaForTesting([&]() { control_handle_closed = true; });
- control_handle.set_disconnect_handler(connection_error_callback);
- response_client.CloseReceiver();
- run_loop.RunUntilIdle();
- // Response pipe is closed, so no results to check. Internal request should be
- // cancelled.
- EXPECT_FALSE(response_client.complete());
- EXPECT_EQ(1, inner_resolver->num_cancellations());
- EXPECT_TRUE(control_handle_closed);
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, CloseClient_SubsequentRequest) {
- std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, nullptr);
- resolver.ResolveHost(net::HostPortPair("localhost", 80),
- net::NetworkIsolationKey(), nullptr,
- std::move(pending_response_client));
- response_client.CloseReceiver();
- run_loop.RunUntilIdle();
- // Not using a hanging resolver, so could be incomplete or OK depending on
- // timing of the cancellation.
- EXPECT_TRUE(!response_client.complete() ||
- response_client.result_error() == net::OK);
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- // Subsequent requests should be unaffected by the cancellation.
- base::RunLoop run_loop2;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client2;
- TestResolveHostClient response_client2(&pending_response_client2, &run_loop2);
- resolver.ResolveHost(net::HostPortPair("localhost", 80),
- net::NetworkIsolationKey(), nullptr,
- std::move(pending_response_client2));
- run_loop2.Run();
- EXPECT_EQ(net::OK, response_client2.result_error());
- EXPECT_THAT(
- response_client2.result_addresses().value().endpoints(),
- testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
- CreateExpectedEndPoint("::1", 80)));
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, Binding) {
- mojo::Remote<mojom::HostResolver> resolver_remote;
- HostResolver* shutdown_resolver = nullptr;
- HostResolver::ConnectionShutdownCallback shutdown_callback =
- base::BindLambdaForTesting(
- [&](HostResolver* resolver) { shutdown_resolver = resolver; });
- std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
- HostResolver resolver(resolver_remote.BindNewPipeAndPassReceiver(),
- std::move(shutdown_callback), inner_resolver.get(),
- net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- // Resolve "localhost" because it should always resolve fast and locally, even
- // when using a real HostResolver.
- resolver_remote->ResolveHost(
- net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_THAT(
- response_client.result_addresses().value().endpoints(),
- testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 160),
- CreateExpectedEndPoint("::1", 160)));
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- EXPECT_FALSE(shutdown_resolver);
- }
- TEST_F(HostResolverTest, CloseBinding) {
- mojo::Remote<mojom::HostResolver> resolver_remote;
- HostResolver* shutdown_resolver = nullptr;
- HostResolver::ConnectionShutdownCallback shutdown_callback =
- base::BindLambdaForTesting(
- [&](HostResolver* resolver) { shutdown_resolver = resolver; });
- // Use a HangingHostResolver, so the test can ensure the request won't be
- // completed before the cancellation arrives.
- auto inner_resolver = std::make_unique<net::HangingHostResolver>();
- HostResolver resolver(resolver_remote.BindNewPipeAndPassReceiver(),
- std::move(shutdown_callback), inner_resolver.get(),
- net::NetLog::Get());
- ASSERT_EQ(0, inner_resolver->num_cancellations());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver_remote->ResolveHost(
- net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- bool control_handle_closed = false;
- auto connection_error_callback =
- base::BindLambdaForTesting([&]() { control_handle_closed = true; });
- control_handle.set_disconnect_handler(connection_error_callback);
- resolver_remote.reset();
- run_loop.Run();
- // Request should be cancelled.
- EXPECT_EQ(net::ERR_FAILED, response_client.result_error());
- EXPECT_FALSE(response_client.result_addresses());
- EXPECT_TRUE(control_handle_closed);
- EXPECT_EQ(1, inner_resolver->num_cancellations());
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- // Callback should have been called.
- EXPECT_EQ(&resolver, shutdown_resolver);
- }
- TEST_F(HostResolverTest, CloseBinding_SubsequentRequest) {
- mojo::Remote<mojom::HostResolver> resolver_remote;
- HostResolver* shutdown_resolver = nullptr;
- HostResolver::ConnectionShutdownCallback shutdown_callback =
- base::BindLambdaForTesting(
- [&](HostResolver* resolver) { shutdown_resolver = resolver; });
- std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
- HostResolver resolver(resolver_remote.BindNewPipeAndPassReceiver(),
- std::move(shutdown_callback), inner_resolver.get(),
- net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, nullptr);
- resolver_remote->ResolveHost(net::HostPortPair("localhost", 160),
- net::NetworkIsolationKey(), nullptr,
- std::move(pending_response_client));
- resolver_remote.reset();
- run_loop.RunUntilIdle();
- // Not using a hanging resolver, so could be ERR_FAILED or OK depending on
- // timing of the cancellation.
- EXPECT_TRUE(response_client.result_error() == net::ERR_FAILED ||
- response_client.result_error() == net::OK);
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- // Callback should have been called.
- EXPECT_EQ(&resolver, shutdown_resolver);
- // Subsequent requests should be unaffected by the cancellation.
- base::RunLoop run_loop2;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client2;
- TestResolveHostClient response_client2(&pending_response_client2, &run_loop2);
- resolver.ResolveHost(net::HostPortPair("localhost", 80),
- net::NetworkIsolationKey(), nullptr,
- std::move(pending_response_client2));
- run_loop2.Run();
- EXPECT_EQ(net::OK, response_client2.result_error());
- EXPECT_THAT(
- response_client2.result_addresses().value().endpoints(),
- testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 80),
- CreateExpectedEndPoint("::1", 80)));
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, IsSpeculative) {
- std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneResolver(net::NetLog::Get());
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- mojom::ResolveHostParametersPtr parameters =
- mojom::ResolveHostParameters::New();
- parameters->is_speculative = true;
- // Resolve "localhost" because it should always resolve fast and locally, even
- // when using a real HostResolver.
- resolver.ResolveHost(net::HostPortPair("localhost", 80),
- net::NetworkIsolationKey(), std::move(parameters),
- std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_FALSE(response_client.result_addresses());
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- net::DnsConfig CreateValidDnsConfig() {
- net::IPAddress dns_ip(192, 168, 1, 0);
- net::DnsConfig config;
- config.nameservers.push_back(
- net::IPEndPoint(dns_ip, net::dns_protocol::kDefaultPort));
- EXPECT_TRUE(config.IsValid());
- return config;
- }
- TEST_F(HostResolverTest, TextResults) {
- static const char* kTextRecords[] = {"foo", "bar", "more text"};
- net::MockDnsClientRuleList rules;
- rules.emplace_back(
- "example.com", net::dns_protocol::kTypeTXT, false /* secure */,
- net::MockDnsClientRule::Result(net::BuildTestDnsTextResponse(
- "example.com", {std::vector<std::string>(std::begin(kTextRecords),
- std::end(kTextRecords))})),
- false /* delay */);
- auto dns_client = std::make_unique<net::MockDnsClient>(CreateValidDnsConfig(),
- std::move(rules));
- dns_client->set_ignore_system_config_changes(true);
- std::unique_ptr<net::ContextHostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneContextResolver(net::NetLog::Get());
- inner_resolver->GetManagerForTesting()->SetDnsClientForTesting(
- std::move(dns_client));
- inner_resolver->GetManagerForTesting()->SetInsecureDnsClientEnabled(
- /*enabled=*/true,
- /*additional_dns_types_enabled=*/true);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->dns_query_type = net::DnsQueryType::TXT;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_FALSE(response_client.result_addresses());
- EXPECT_THAT(response_client.result_text(),
- testing::Optional(testing::ElementsAreArray(kTextRecords)));
- EXPECT_FALSE(response_client.result_hosts());
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, HostResults) {
- net::MockDnsClientRuleList rules;
- rules.emplace_back(
- "example.com", net::dns_protocol::kTypePTR, false /*secure */,
- net::MockDnsClientRule::Result(net::BuildTestDnsPointerResponse(
- "example.com", {"google.com", "chromium.org"})),
- false /* delay */);
- auto dns_client = std::make_unique<net::MockDnsClient>(CreateValidDnsConfig(),
- std::move(rules));
- dns_client->set_ignore_system_config_changes(true);
- std::unique_ptr<net::ContextHostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneContextResolver(net::NetLog::Get());
- inner_resolver->GetManagerForTesting()->SetDnsClientForTesting(
- std::move(dns_client));
- inner_resolver->GetManagerForTesting()->SetInsecureDnsClientEnabled(
- /*enabled=*/true,
- /*additional_dns_types_enabled=*/true);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->dns_query_type = net::DnsQueryType::PTR;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- EXPECT_FALSE(response_client.result_addresses());
- EXPECT_FALSE(response_client.result_text());
- EXPECT_THAT(response_client.result_hosts(),
- testing::Optional(testing::UnorderedElementsAre(
- net::HostPortPair("google.com", 160),
- net::HostPortPair("chromium.org", 160))));
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- TEST_F(HostResolverTest, RespectsDisablingAdditionalQueryTypes) {
- net::MockDnsClientRuleList rules;
- auto dns_client = std::make_unique<net::MockDnsClient>(CreateValidDnsConfig(),
- std::move(rules));
- dns_client->set_ignore_system_config_changes(true);
- std::unique_ptr<net::ContextHostResolver> inner_resolver =
- net::HostResolver::CreateStandaloneContextResolver(net::NetLog::Get());
- inner_resolver->GetManagerForTesting()->SetDnsClientForTesting(
- std::move(dns_client));
- inner_resolver->GetManagerForTesting()->SetInsecureDnsClientEnabled(
- /*enabled=*/true,
- /*additional_dns_types_enabled=*/false);
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->dns_query_type = net::DnsQueryType::PTR;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- // No queries made, so result is `ERR_DNS_CACHE_MISS`.
- EXPECT_THAT(response_client.result_error(),
- net::test::IsError(net::ERR_DNS_CACHE_MISS));
- EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
- }
- #if BUILDFLAG(ENABLE_MDNS)
- TEST_F(HostResolverTest, MdnsListener_AddressResult) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
- TestMdnsListenClient response_client(&pending_response_client);
- int error = net::ERR_FAILED;
- base::RunLoop run_loop;
- net::HostPortPair host("host.local", 41);
- resolver.MdnsListen(host, net::DnsQueryType::A,
- std::move(pending_response_client),
- base::BindLambdaForTesting([&](int error_val) {
- error = error_val;
- run_loop.Quit();
- }));
- run_loop.Run();
- ASSERT_EQ(net::OK, error);
- net::IPAddress result_address(1, 2, 3, 4);
- net::IPEndPoint result(result_address, 41);
- inner_resolver->TriggerMdnsListeners(
- host, net::DnsQueryType::A, net::MdnsListenerUpdateType::kAdded, result);
- base::RunLoop().RunUntilIdle();
- EXPECT_THAT(
- response_client.address_results(),
- testing::ElementsAre(TestMdnsListenClient::CreateExpectedResult(
- net::MdnsListenerUpdateType::kAdded, net::DnsQueryType::A, result)));
- EXPECT_THAT(response_client.text_results(), testing::IsEmpty());
- EXPECT_THAT(response_client.hostname_results(), testing::IsEmpty());
- EXPECT_THAT(response_client.unhandled_results(), testing::IsEmpty());
- }
- TEST_F(HostResolverTest, MdnsListener_TextResult) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
- TestMdnsListenClient response_client(&pending_response_client);
- int error = net::ERR_FAILED;
- base::RunLoop run_loop;
- net::HostPortPair host("host.local", 42);
- resolver.MdnsListen(host, net::DnsQueryType::TXT,
- std::move(pending_response_client),
- base::BindLambdaForTesting([&](int error_val) {
- error = error_val;
- run_loop.Quit();
- }));
- run_loop.Run();
- ASSERT_EQ(net::OK, error);
- inner_resolver->TriggerMdnsListeners(host, net::DnsQueryType::TXT,
- net::MdnsListenerUpdateType::kChanged,
- {"foo", "bar"});
- base::RunLoop().RunUntilIdle();
- EXPECT_THAT(
- response_client.text_results(),
- testing::UnorderedElementsAre(TestMdnsListenClient::CreateExpectedResult(
- net::MdnsListenerUpdateType::kChanged,
- net::DnsQueryType::TXT, "foo"),
- TestMdnsListenClient::CreateExpectedResult(
- net::MdnsListenerUpdateType::kChanged,
- net::DnsQueryType::TXT, "bar")));
- EXPECT_THAT(response_client.address_results(), testing::IsEmpty());
- EXPECT_THAT(response_client.hostname_results(), testing::IsEmpty());
- EXPECT_THAT(response_client.unhandled_results(), testing::IsEmpty());
- }
- TEST_F(HostResolverTest, MdnsListener_HostnameResult) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
- TestMdnsListenClient response_client(&pending_response_client);
- int error = net::ERR_FAILED;
- base::RunLoop run_loop;
- net::HostPortPair host("host.local", 43);
- resolver.MdnsListen(host, net::DnsQueryType::PTR,
- std::move(pending_response_client),
- base::BindLambdaForTesting([&](int error_val) {
- error = error_val;
- run_loop.Quit();
- }));
- run_loop.Run();
- ASSERT_EQ(net::OK, error);
- net::HostPortPair result("example.com", 43);
- inner_resolver->TriggerMdnsListeners(host, net::DnsQueryType::PTR,
- net::MdnsListenerUpdateType::kRemoved,
- result);
- base::RunLoop().RunUntilIdle();
- EXPECT_THAT(response_client.hostname_results(),
- testing::ElementsAre(TestMdnsListenClient::CreateExpectedResult(
- net::MdnsListenerUpdateType::kRemoved, net::DnsQueryType::PTR,
- result)));
- EXPECT_THAT(response_client.address_results(), testing::IsEmpty());
- EXPECT_THAT(response_client.text_results(), testing::IsEmpty());
- EXPECT_THAT(response_client.unhandled_results(), testing::IsEmpty());
- }
- TEST_F(HostResolverTest, MdnsListener_UnhandledResult) {
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
- TestMdnsListenClient response_client(&pending_response_client);
- int error = net::ERR_FAILED;
- base::RunLoop run_loop;
- net::HostPortPair host("host.local", 44);
- resolver.MdnsListen(host, net::DnsQueryType::PTR,
- std::move(pending_response_client),
- base::BindLambdaForTesting([&](int error_val) {
- error = error_val;
- run_loop.Quit();
- }));
- run_loop.Run();
- ASSERT_EQ(net::OK, error);
- inner_resolver->TriggerMdnsListeners(host, net::DnsQueryType::PTR,
- net::MdnsListenerUpdateType::kAdded);
- base::RunLoop().RunUntilIdle();
- EXPECT_THAT(
- response_client.unhandled_results(),
- testing::ElementsAre(std::make_pair(net::MdnsListenerUpdateType::kAdded,
- net::DnsQueryType::PTR)));
- EXPECT_THAT(response_client.address_results(), testing::IsEmpty());
- EXPECT_THAT(response_client.text_results(), testing::IsEmpty());
- EXPECT_THAT(response_client.hostname_results(), testing::IsEmpty());
- }
- #endif // BUILDFLAG(ENABLE_MDNS)
- #if BUILDFLAG(IS_ANDROID)
- class HostResolverRecordRadioWakeupTest : public HostResolverTest {
- public:
- HostResolverRecordRadioWakeupTest() {
- scoped_feature_list_.InitAndEnableFeature(
- net::features::kRecordRadioWakeupTrigger);
- }
- private:
- base::test::ScopedFeatureList scoped_feature_list_;
- };
- TEST_F(HostResolverRecordRadioWakeupTest, RecordPreconnect) {
- base::HistogramTester histograms;
- net::android::RadioActivityTracker::GetInstance()
- .OverrideRadioActivityForTesting(
- base::android::RadioDataActivity::kDormant);
- net::android::RadioActivityTracker::GetInstance().OverrideRadioTypeForTesting(
- base::android::RadioConnectionType::kCell);
- auto inner_resolver = std::make_unique<net::MockHostResolver>();
- inner_resolver->set_synchronous_mode(false);
- inner_resolver->rules()->AddRule("example.com", "1.2.3.4");
- HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
- base::RunLoop run_loop;
- mojo::Remote<mojom::ResolveHostHandle> control_handle;
- mojom::ResolveHostParametersPtr optional_parameters =
- mojom::ResolveHostParameters::New();
- optional_parameters->control_handle =
- control_handle.BindNewPipeAndPassReceiver();
- optional_parameters->purpose =
- mojom::ResolveHostParameters::Purpose::kPreconnect;
- mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
- TestResolveHostClient response_client(&pending_response_client, &run_loop);
- resolver.ResolveHost(
- net::HostPortPair("example.com", 160), net::NetworkIsolationKey(),
- std::move(optional_parameters), std::move(pending_response_client));
- run_loop.Run();
- EXPECT_EQ(net::OK, response_client.result_error());
- histograms.ExpectUniqueSample(
- kUmaNamePossibleWakeupTriggerResolveHost,
- mojom::ResolveHostParameters::Purpose::kPreconnect, 1);
- }
- #endif // BUILDFLAG(IS_ANDROID)
- } // namespace
- } // namespace network
|