| // Copyright (c) 2012 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 "net/dns/host_resolver_impl.h" |
| |
| #include <string> |
| #include <tuple> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/auto_reset.h" |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/location.h" |
| #include "base/macros.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/run_loop.h" |
| #include "base/single_thread_task_runner.h" |
| #include "base/stl_util.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/synchronization/condition_variable.h" |
| #include "base/synchronization/lock.h" |
| #include "base/test/bind_test_util.h" |
| #include "base/test/test_mock_time_task_runner.h" |
| #include "base/test/test_timeouts.h" |
| #include "base/threading/thread_restrictions.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "base/time/time.h" |
| #include "base/values.h" |
| #include "net/base/address_list.h" |
| #include "net/base/ip_address.h" |
| #include "net/base/mock_network_change_notifier.h" |
| #include "net/base/net_errors.h" |
| #include "net/dns/dns_client.h" |
| #include "net/dns/dns_test_util.h" |
| #include "net/dns/mock_host_resolver.h" |
| #include "net/dns/mock_mdns_client.h" |
| #include "net/dns/mock_mdns_socket_factory.h" |
| #include "net/log/net_log_event_type.h" |
| #include "net/log/net_log_source_type.h" |
| #include "net/log/net_log_with_source.h" |
| #include "net/log/test_net_log.h" |
| #include "net/test/gtest_util.h" |
| #include "net/test/test_with_scoped_task_environment.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| using net::test::IsError; |
| using net::test::IsOk; |
| using ::testing::_; |
| using ::testing::Between; |
| using ::testing::ByMove; |
| using ::testing::NotNull; |
| using ::testing::Return; |
| |
| namespace net { |
| |
| namespace { |
| |
| const size_t kMaxJobs = 10u; |
| const size_t kMaxRetryAttempts = 4u; |
| |
| HostResolver::Options DefaultOptions() { |
| HostResolver::Options options; |
| options.max_concurrent_resolves = kMaxJobs; |
| options.max_retry_attempts = kMaxRetryAttempts; |
| options.enable_caching = true; |
| return options; |
| } |
| |
| HostResolverImpl::ProcTaskParams DefaultParams( |
| HostResolverProc* resolver_proc) { |
| return HostResolverImpl::ProcTaskParams(resolver_proc, kMaxRetryAttempts); |
| } |
| |
| // A HostResolverProc that pushes each host mapped into a list and allows |
| // waiting for a specific number of requests. Unlike RuleBasedHostResolverProc |
| // it never calls SystemHostResolverCall. By default resolves all hostnames to |
| // "127.0.0.1". After AddRule(), it resolves only names explicitly specified. |
| class MockHostResolverProc : public HostResolverProc { |
| public: |
| struct ResolveKey { |
| ResolveKey(const std::string& hostname, |
| AddressFamily address_family, |
| HostResolverFlags flags) |
| : hostname(hostname), address_family(address_family), flags(flags) {} |
| bool operator<(const ResolveKey& other) const { |
| return std::tie(address_family, hostname, flags) < |
| std::tie(other.address_family, other.hostname, other.flags); |
| } |
| std::string hostname; |
| AddressFamily address_family; |
| HostResolverFlags flags; |
| }; |
| |
| typedef std::vector<ResolveKey> CaptureList; |
| |
| MockHostResolverProc() |
| : HostResolverProc(NULL), |
| num_requests_waiting_(0), |
| num_slots_available_(0), |
| requests_waiting_(&lock_), |
| slots_available_(&lock_) { |
| } |
| |
| // Waits until |count| calls to |Resolve| are blocked. Returns false when |
| // timed out. |
| bool WaitFor(unsigned count) { |
| base::AutoLock lock(lock_); |
| base::Time start_time = base::Time::Now(); |
| while (num_requests_waiting_ < count) { |
| requests_waiting_.TimedWait(TestTimeouts::action_timeout()); |
| if (base::Time::Now() > start_time + TestTimeouts::action_timeout()) |
| return false; |
| } |
| return true; |
| } |
| |
| // Signals |count| waiting calls to |Resolve|. First come first served. |
| void SignalMultiple(unsigned count) { |
| base::AutoLock lock(lock_); |
| num_slots_available_ += count; |
| slots_available_.Broadcast(); |
| } |
| |
| // Signals all waiting calls to |Resolve|. Beware of races. |
| void SignalAll() { |
| base::AutoLock lock(lock_); |
| num_slots_available_ = num_requests_waiting_; |
| slots_available_.Broadcast(); |
| } |
| |
| void AddRule(const std::string& hostname, |
| AddressFamily family, |
| const AddressList& result, |
| HostResolverFlags flags = 0) { |
| base::AutoLock lock(lock_); |
| rules_[ResolveKey(hostname, family, flags)] = result; |
| } |
| |
| void AddRule(const std::string& hostname, |
| AddressFamily family, |
| const std::string& ip_list, |
| HostResolverFlags flags = 0, |
| const std::string& canonical_name = "") { |
| AddressList result; |
| int rv = ParseAddressList(ip_list, canonical_name, &result); |
| DCHECK_EQ(OK, rv); |
| AddRule(hostname, family, result, flags); |
| } |
| |
| void AddRuleForAllFamilies(const std::string& hostname, |
| const std::string& ip_list, |
| HostResolverFlags flags = 0, |
| const std::string& canonical_name = "") { |
| AddressList result; |
| int rv = ParseAddressList(ip_list, canonical_name, &result); |
| DCHECK_EQ(OK, rv); |
| AddRule(hostname, ADDRESS_FAMILY_UNSPECIFIED, result, flags); |
| AddRule(hostname, ADDRESS_FAMILY_IPV4, result, flags); |
| AddRule(hostname, ADDRESS_FAMILY_IPV6, result, flags); |
| #if !SB_HAS(IPV6) |
| if ((flags & HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6) == 0) { |
| AddRule(hostname, ADDRESS_FAMILY_UNSPECIFIED, result, |
| HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6); |
| AddRule(hostname, ADDRESS_FAMILY_IPV4, result, |
| HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6); |
| } |
| #endif |
| } |
| |
| int Resolve(const std::string& hostname, |
| AddressFamily address_family, |
| HostResolverFlags host_resolver_flags, |
| AddressList* addrlist, |
| int* os_error) override { |
| base::AutoLock lock(lock_); |
| capture_list_.push_back( |
| ResolveKey(hostname, address_family, host_resolver_flags)); |
| ++num_requests_waiting_; |
| requests_waiting_.Broadcast(); |
| { |
| base::ScopedAllowBaseSyncPrimitivesForTesting |
| scoped_allow_base_sync_primitives; |
| while (!num_slots_available_) |
| slots_available_.Wait(); |
| } |
| DCHECK_GT(num_requests_waiting_, 0u); |
| --num_slots_available_; |
| --num_requests_waiting_; |
| if (rules_.empty()) { |
| int rv = ParseAddressList("127.0.0.1", std::string(), addrlist); |
| DCHECK_EQ(OK, rv); |
| return OK; |
| } |
| ResolveKey key(hostname, address_family, host_resolver_flags); |
| if (rules_.count(key) == 0) |
| return ERR_NAME_NOT_RESOLVED; |
| *addrlist = rules_[key]; |
| return OK; |
| } |
| |
| CaptureList GetCaptureList() const { |
| CaptureList copy; |
| { |
| base::AutoLock lock(lock_); |
| copy = capture_list_; |
| } |
| return copy; |
| } |
| |
| bool HasBlockedRequests() const { |
| base::AutoLock lock(lock_); |
| return num_requests_waiting_ > num_slots_available_; |
| } |
| |
| protected: |
| ~MockHostResolverProc() override = default; |
| |
| private: |
| mutable base::Lock lock_; |
| std::map<ResolveKey, AddressList> rules_; |
| CaptureList capture_list_; |
| unsigned num_requests_waiting_; |
| unsigned num_slots_available_; |
| base::ConditionVariable requests_waiting_; |
| base::ConditionVariable slots_available_; |
| |
| DISALLOW_COPY_AND_ASSIGN(MockHostResolverProc); |
| }; |
| |
| bool AddressListContains(const AddressList& list, |
| const std::string& address, |
| uint16_t port) { |
| IPAddress ip; |
| bool rv = ip.AssignFromIPLiteral(address); |
| DCHECK(rv); |
| return base::ContainsValue(list, IPEndPoint(ip, port)); |
| } |
| |
| class ResolveHostResponseHelper { |
| public: |
| using Callback = |
| base::OnceCallback<void(CompletionOnceCallback completion_callback, |
| int error)>; |
| |
| ResolveHostResponseHelper() {} |
| explicit ResolveHostResponseHelper( |
| std::unique_ptr<HostResolver::ResolveHostRequest> request) |
| : request_(std::move(request)) { |
| result_error_ = request_->Start(base::BindOnce( |
| &ResolveHostResponseHelper::OnComplete, base::Unretained(this))); |
| } |
| ResolveHostResponseHelper( |
| std::unique_ptr<HostResolver::ResolveHostRequest> request, |
| Callback custom_callback) |
| : request_(std::move(request)) { |
| result_error_ = request_->Start( |
| base::BindOnce(std::move(custom_callback), |
| base::BindOnce(&ResolveHostResponseHelper::OnComplete, |
| base::Unretained(this)))); |
| } |
| |
| bool complete() const { return result_error_ != ERR_IO_PENDING; } |
| int result_error() { |
| WaitForCompletion(); |
| return result_error_; |
| } |
| |
| HostResolver::ResolveHostRequest* request() { return request_.get(); } |
| |
| void CancelRequest() { |
| DCHECK(request_); |
| DCHECK(!complete()); |
| |
| request_ = nullptr; |
| } |
| |
| void OnComplete(int error) { |
| DCHECK(!complete()); |
| result_error_ = error; |
| |
| run_loop_.Quit(); |
| } |
| |
| private: |
| void WaitForCompletion() { |
| DCHECK(request_); |
| if (complete()) { |
| return; |
| } |
| run_loop_.Run(); |
| DCHECK(complete()); |
| } |
| |
| std::unique_ptr<HostResolver::ResolveHostRequest> request_; |
| int result_error_ = ERR_IO_PENDING; |
| base::RunLoop run_loop_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ResolveHostResponseHelper); |
| }; |
| |
| // A wrapper for requests to a HostResolver. |
| class Request { |
| public: |
| // Base class of handlers to be executed on completion of requests. |
| struct Handler { |
| virtual ~Handler() = default; |
| virtual void Handle(Request* request) = 0; |
| }; |
| |
| Request(const HostResolver::RequestInfo& info, |
| RequestPriority priority, |
| size_t index, |
| HostResolverImpl* resolver, |
| Handler* handler) |
| : info_(info), |
| priority_(priority), |
| index_(index), |
| resolver_(resolver), |
| handler_(handler), |
| result_(ERR_UNEXPECTED) {} |
| |
| int Resolve() { |
| DCHECK(resolver_); |
| DCHECK(!request_); |
| list_ = AddressList(); |
| result_ = resolver_->Resolve( |
| info_, priority_, &list_, |
| base::Bind(&Request::OnComplete, base::Unretained(this)), &request_, |
| NetLogWithSource()); |
| if (!list_.empty()) |
| EXPECT_THAT(result_, IsOk()); |
| return result_; |
| } |
| |
| int ResolveFromCache() { |
| DCHECK(resolver_); |
| DCHECK(!request_); |
| return resolver_->ResolveFromCache(info_, &list_, NetLogWithSource()); |
| } |
| |
| int ResolveStaleFromCache() { |
| DCHECK(resolver_); |
| DCHECK(!request_); |
| return resolver_->ResolveStaleFromCache(info_, &list_, &staleness_, |
| NetLogWithSource()); |
| } |
| |
| void ChangePriority(RequestPriority priority) { |
| DCHECK(resolver_); |
| DCHECK(request_); |
| request_->ChangeRequestPriority(priority); |
| priority_ = priority; |
| } |
| |
| void Cancel() { |
| DCHECK(resolver_); |
| DCHECK(request_); |
| request_.reset(); |
| } |
| |
| const HostResolver::RequestInfo& info() const { return info_; } |
| size_t index() const { return index_; } |
| const AddressList& list() const { return list_; } |
| int result() const { return result_; } |
| const HostCache::EntryStaleness staleness() const { return staleness_; } |
| bool completed() const { return result_ != ERR_IO_PENDING; } |
| bool pending() const { return request_ != nullptr; } |
| |
| bool HasAddress(const std::string& address, uint16_t port) const { |
| return AddressListContains(list_, address, port); |
| } |
| |
| // Returns the number of addresses in |list_|. |
| unsigned NumberOfAddresses() const { |
| return list_.size(); |
| } |
| |
| bool HasOneAddress(const std::string& address, uint16_t port) const { |
| return HasAddress(address, port) && (NumberOfAddresses() == 1u); |
| } |
| |
| // Returns ERR_UNEXPECTED if timed out. |
| int WaitForResult() { |
| if (completed()) |
| return result_; |
| base::RunLoop run_loop; |
| base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
| FROM_HERE, run_loop.QuitClosure(), TestTimeouts::action_max_timeout()); |
| base::AutoReset<base::OnceClosure> reset(&quit_closure_, |
| run_loop.QuitClosure()); |
| run_loop.Run(); |
| if (!quit_closure_) |
| return result_; |
| else |
| return ERR_UNEXPECTED; |
| } |
| |
| private: |
| void OnComplete(int rv) { |
| EXPECT_TRUE(pending()); |
| EXPECT_THAT(result_, IsError(ERR_IO_PENDING)); |
| EXPECT_NE(ERR_IO_PENDING, rv); |
| result_ = rv; |
| request_.reset(); |
| if (!list_.empty()) { |
| EXPECT_THAT(result_, IsOk()); |
| EXPECT_EQ(info_.port(), list_.front().port()); |
| } |
| if (handler_) |
| handler_->Handle(this); |
| if (quit_closure_) |
| std::move(quit_closure_).Run(); |
| } |
| |
| HostResolver::RequestInfo info_; |
| RequestPriority priority_; |
| size_t index_; |
| HostResolverImpl* resolver_; |
| Handler* handler_; |
| base::OnceClosure quit_closure_; |
| |
| AddressList list_; |
| int result_; |
| std::unique_ptr<HostResolver::Request> request_; |
| HostCache::EntryStaleness staleness_; |
| |
| DISALLOW_COPY_AND_ASSIGN(Request); |
| }; |
| |
| // Using LookupAttemptHostResolverProc simulate very long lookups, and control |
| // which attempt resolves the host. |
| class LookupAttemptHostResolverProc : public HostResolverProc { |
| public: |
| LookupAttemptHostResolverProc(HostResolverProc* previous, |
| int attempt_number_to_resolve, |
| int total_attempts) |
| : HostResolverProc(previous), |
| attempt_number_to_resolve_(attempt_number_to_resolve), |
| current_attempt_number_(0), |
| total_attempts_(total_attempts), |
| total_attempts_resolved_(0), |
| resolved_attempt_number_(0), |
| num_attempts_waiting_(0), |
| all_done_(&lock_), |
| blocked_attempt_signal_(&lock_) {} |
| |
| // Test harness will wait for all attempts to finish before checking the |
| // results. |
| void WaitForAllAttemptsToFinish() { |
| base::AutoLock auto_lock(lock_); |
| while (total_attempts_resolved_ != total_attempts_) { |
| all_done_.Wait(); |
| } |
| } |
| |
| void WaitForNAttemptsToBeBlocked(int n) { |
| base::AutoLock auto_lock(lock_); |
| while (num_attempts_waiting_ < n) { |
| blocked_attempt_signal_.Wait(); |
| } |
| } |
| |
| // All attempts will wait for an attempt to resolve the host. |
| void WaitForAnAttemptToComplete() { |
| { |
| base::AutoLock auto_lock(lock_); |
| base::ScopedAllowBaseSyncPrimitivesForTesting |
| scoped_allow_base_sync_primitives; |
| while (resolved_attempt_number_ == 0) |
| all_done_.Wait(); |
| } |
| all_done_.Broadcast(); // Tell all waiting attempts to proceed. |
| } |
| |
| // Returns the number of attempts that have finished the Resolve() method. |
| int total_attempts_resolved() { return total_attempts_resolved_; } |
| |
| // Returns the first attempt that that has resolved the host. |
| int resolved_attempt_number() { return resolved_attempt_number_; } |
| |
| // Returns the current number of blocked attempts. |
| int num_attempts_waiting() { return num_attempts_waiting_; } |
| |
| // HostResolverProc methods. |
| int Resolve(const std::string& host, |
| AddressFamily address_family, |
| HostResolverFlags host_resolver_flags, |
| AddressList* addrlist, |
| int* os_error) override { |
| bool wait_for_right_attempt_to_complete = true; |
| { |
| base::AutoLock auto_lock(lock_); |
| ++current_attempt_number_; |
| ++num_attempts_waiting_; |
| if (current_attempt_number_ == attempt_number_to_resolve_) { |
| resolved_attempt_number_ = current_attempt_number_; |
| wait_for_right_attempt_to_complete = false; |
| } |
| } |
| |
| blocked_attempt_signal_.Broadcast(); |
| |
| if (wait_for_right_attempt_to_complete) |
| // Wait for the attempt_number_to_resolve_ attempt to resolve. |
| WaitForAnAttemptToComplete(); |
| |
| int result = ResolveUsingPrevious(host, address_family, host_resolver_flags, |
| addrlist, os_error); |
| |
| { |
| base::AutoLock auto_lock(lock_); |
| ++total_attempts_resolved_; |
| --num_attempts_waiting_; |
| } |
| |
| all_done_.Broadcast(); // Tell all attempts to proceed. |
| |
| // Since any negative number is considered a network error, with -1 having |
| // special meaning (ERR_IO_PENDING). We could return the attempt that has |
| // resolved the host as a negative number. For example, if attempt number 3 |
| // resolves the host, then this method returns -4. |
| if (result == OK) |
| return -1 - resolved_attempt_number_; |
| else |
| return result; |
| } |
| |
| protected: |
| ~LookupAttemptHostResolverProc() override = default; |
| |
| private: |
| int attempt_number_to_resolve_; |
| int current_attempt_number_; // Incremented whenever Resolve is called. |
| int total_attempts_; |
| int total_attempts_resolved_; |
| int resolved_attempt_number_; |
| int num_attempts_waiting_; |
| |
| // All attempts wait for right attempt to be resolve. |
| base::Lock lock_; |
| base::ConditionVariable all_done_; |
| base::ConditionVariable blocked_attempt_signal_; |
| }; |
| |
| // TestHostResolverImpl's sole purpose is to mock the IPv6 reachability test. |
| // By default, this pretends that IPv6 is globally reachable. |
| // This class is necessary so unit tests run the same on dual-stack machines as |
| // well as IPv4 only machines. |
| class TestHostResolverImpl : public HostResolverImpl { |
| public: |
| TestHostResolverImpl(const Options& options, NetLog* net_log) |
| : TestHostResolverImpl(options, net_log, true) {} |
| |
| TestHostResolverImpl(const Options& options, |
| NetLog* net_log, |
| bool ipv6_reachable) |
| : HostResolverImpl(options, net_log), ipv6_reachable_(ipv6_reachable) {} |
| |
| ~TestHostResolverImpl() override = default; |
| |
| private: |
| const bool ipv6_reachable_; |
| |
| bool IsGloballyReachable(const IPAddress& dest, |
| const NetLogWithSource& net_log) override { |
| return ipv6_reachable_; |
| } |
| }; |
| |
| const uint16_t kLocalhostLookupPort = 80; |
| |
| bool HasEndpoint(const IPEndPoint& endpoint, const AddressList& addresses) { |
| for (const auto& address : addresses) { |
| if (endpoint == address) |
| return true; |
| } |
| return false; |
| } |
| |
| void TestBothLoopbackIPs(const std::string& host) { |
| IPEndPoint localhost_ipv4(IPAddress::IPv4Localhost(), kLocalhostLookupPort); |
| IPEndPoint localhost_ipv6(IPAddress::IPv6Localhost(), kLocalhostLookupPort); |
| |
| AddressList addresses; |
| EXPECT_TRUE(ResolveLocalHostname(host, kLocalhostLookupPort, &addresses)); |
| EXPECT_EQ(2u, addresses.size()); |
| EXPECT_TRUE(HasEndpoint(localhost_ipv4, addresses)); |
| EXPECT_TRUE(HasEndpoint(localhost_ipv6, addresses)); |
| } |
| |
| void TestIPv6LoopbackOnly(const std::string& host) { |
| IPEndPoint localhost_ipv6(IPAddress::IPv6Localhost(), kLocalhostLookupPort); |
| |
| AddressList addresses; |
| EXPECT_TRUE(ResolveLocalHostname(host, kLocalhostLookupPort, &addresses)); |
| EXPECT_EQ(1u, addresses.size()); |
| EXPECT_TRUE(HasEndpoint(localhost_ipv6, addresses)); |
| } |
| |
| // Used to bind the unique_ptr<Request>* into callbacks. |
| struct RequestHolder { |
| std::unique_ptr<HostResolver::Request> request; |
| }; |
| |
| } // namespace |
| |
| class HostResolverImplTest : public TestWithScopedTaskEnvironment { |
| public: |
| static const int kDefaultPort = 80; |
| |
| HostResolverImplTest() : proc_(new MockHostResolverProc()) {} |
| |
| void CreateResolver() { |
| CreateResolverWithLimitsAndParams(kMaxJobs, DefaultParams(proc_.get()), |
| #if !defined(STARBOARD) || SB_HAS(IPV6) |
| true /* ipv6_reachable */); |
| #else |
| false /* ipv6_reachable */); |
| #endif |
| } |
| |
| // This HostResolverImpl will only allow 1 outstanding resolve at a time and |
| // perform no retries. |
| void CreateSerialResolver() { |
| HostResolverImpl::ProcTaskParams params = DefaultParams(proc_.get()); |
| params.max_retry_attempts = 0u; |
| #if !defined(STARBOARD) || SB_HAS(IPV6) |
| CreateResolverWithLimitsAndParams(1u, params, true /* ipv6_reachable */); |
| #else |
| CreateResolverWithLimitsAndParams(1u, params, false /* ipv6_reachable */); |
| #endif |
| } |
| |
| protected: |
| // A Request::Handler which is a proxy to the HostResolverImplTest fixture. |
| struct Handler : public Request::Handler { |
| ~Handler() override = default; |
| |
| // Proxy functions so that classes derived from Handler can access them. |
| Request* CreateRequest(const HostResolver::RequestInfo& info, |
| RequestPriority priority) { |
| return test->CreateRequest(info, priority); |
| } |
| Request* CreateRequest(const std::string& hostname, int port) { |
| return test->CreateRequest(hostname, port); |
| } |
| Request* CreateRequest(const std::string& hostname) { |
| return test->CreateRequest(hostname); |
| } |
| std::vector<std::unique_ptr<Request>>& requests() { |
| return test->requests_; |
| } |
| |
| void DeleteResolver() { test->resolver_.reset(); } |
| |
| HostResolverImplTest* test; |
| }; |
| |
| // testing::Test implementation: |
| void SetUp() override { CreateResolver(); } |
| |
| void TearDown() override { |
| if (resolver_.get()) |
| EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests()); |
| EXPECT_FALSE(proc_->HasBlockedRequests()); |
| } |
| |
| virtual void CreateResolverWithLimitsAndParams( |
| size_t max_concurrent_resolves, |
| const HostResolverImpl::ProcTaskParams& params, |
| bool ipv6_reachable) { |
| HostResolverImpl::Options options = DefaultOptions(); |
| options.max_concurrent_resolves = max_concurrent_resolves; |
| resolver_.reset(new TestHostResolverImpl(options, NULL, ipv6_reachable)); |
| resolver_->set_proc_params_for_test(params); |
| } |
| |
| // The Request will not be made until a call to |Resolve()|, and the Job will |
| // not start until released by |proc_->SignalXXX|. |
| Request* CreateRequest(const HostResolver::RequestInfo& info, |
| RequestPriority priority) { |
| requests_.push_back(std::make_unique<Request>( |
| info, priority, requests_.size(), resolver_.get(), handler_.get())); |
| return requests_.back().get(); |
| } |
| |
| Request* CreateRequest(const std::string& hostname, |
| int port, |
| RequestPriority priority, |
| AddressFamily family) { |
| HostResolver::RequestInfo info(HostPortPair(hostname, port)); |
| info.set_address_family(family); |
| return CreateRequest(info, priority); |
| } |
| |
| Request* CreateRequest(const std::string& hostname, |
| int port, |
| RequestPriority priority) { |
| return CreateRequest(hostname, port, priority, ADDRESS_FAMILY_UNSPECIFIED); |
| } |
| |
| Request* CreateRequest(const std::string& hostname, int port) { |
| return CreateRequest(hostname, port, MEDIUM); |
| } |
| |
| Request* CreateRequest(const std::string& hostname) { |
| return CreateRequest(hostname, kDefaultPort); |
| } |
| |
| void set_handler(Handler* handler) { |
| handler_.reset(handler); |
| handler_->test = this; |
| } |
| |
| // Friendship is not inherited, so use proxies to access those. |
| size_t num_running_dispatcher_jobs() const { |
| DCHECK(resolver_.get()); |
| return resolver_->num_running_dispatcher_jobs_for_tests(); |
| } |
| |
| void set_fallback_to_proctask(bool fallback_to_proctask) { |
| DCHECK(resolver_.get()); |
| resolver_->fallback_to_proctask_ = fallback_to_proctask; |
| } |
| |
| static unsigned maximum_dns_failures() { |
| return HostResolverImpl::kMaximumDnsFailures; |
| } |
| |
| bool IsIPv6Reachable(const NetLogWithSource& net_log) { |
| return resolver_->IsIPv6Reachable(net_log); |
| } |
| |
| const HostCache::Entry* GetCacheEntry(const Request& req) { |
| DCHECK(resolver_.get() && resolver_->GetHostCache()); |
| const HostCache::Key key(req.info().hostname(), req.info().address_family(), |
| req.info().host_resolver_flags()); |
| return resolver_->GetHostCache()->LookupStale(key, base::TimeTicks(), |
| nullptr); |
| } |
| |
| void MakeCacheStale() { |
| DCHECK(resolver_.get()); |
| resolver_->GetHostCache()->OnNetworkChange(); |
| } |
| |
| IPEndPoint CreateExpected(const std::string& ip_literal, uint16_t port) { |
| IPAddress ip; |
| bool result = ip.AssignFromIPLiteral(ip_literal); |
| DCHECK(result); |
| return IPEndPoint(ip, port); |
| } |
| |
| scoped_refptr<MockHostResolverProc> proc_; |
| std::unique_ptr<HostResolverImpl> resolver_; |
| std::vector<std::unique_ptr<Request>> requests_; |
| |
| std::unique_ptr<Handler> handler_; |
| }; |
| |
| TEST_F(HostResolverImplTest, AsynchronousLookup) { |
| proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42"); |
| proc_->SignalMultiple(1u); |
| |
| Request* req = CreateRequest("just.testing", 80); |
| EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(req->WaitForResult(), IsOk()); |
| |
| EXPECT_TRUE(req->HasOneAddress("192.168.1.42", 80)); |
| EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); |
| } |
| |
| TEST_F(HostResolverImplTest, AsynchronousLookup_ResolveHost) { |
| proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42"); |
| proc_->SignalMultiple(1u); |
| |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt)); |
| |
| EXPECT_THAT(response.result_error(), IsOk()); |
| EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("192.168.1.42", 80))); |
| |
| EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); |
| } |
| |
| TEST_F(HostResolverImplTest, DnsQueryType) { |
| proc_->AddRule("host", ADDRESS_FAMILY_IPV4, "192.168.1.20"); |
| proc_->AddRule("host", ADDRESS_FAMILY_IPV6, "::5"); |
| |
| HostResolver::ResolveHostParameters parameters; |
| |
| parameters.dns_query_type = HostResolver::DnsQueryType::A; |
| ResolveHostResponseHelper v4_response(resolver_->CreateRequest( |
| HostPortPair("host", 80), NetLogWithSource(), parameters)); |
| |
| parameters.dns_query_type = HostResolver::DnsQueryType::AAAA; |
| ResolveHostResponseHelper v6_response(resolver_->CreateRequest( |
| HostPortPair("host", 80), NetLogWithSource(), parameters)); |
| |
| proc_->SignalMultiple(2u); |
| |
| EXPECT_THAT(v4_response.result_error(), IsOk()); |
| EXPECT_THAT(v4_response.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("192.168.1.20", 80))); |
| |
| EXPECT_THAT(v6_response.result_error(), IsOk()); |
| EXPECT_THAT(v6_response.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("::5", 80))); |
| } |
| |
| TEST_F(HostResolverImplTest, LocalhostIPV4IPV6Lookup) { |
| Request* req1 = CreateRequest("localhost6", 80, MEDIUM, ADDRESS_FAMILY_IPV4); |
| EXPECT_THAT(req1->Resolve(), IsOk()); |
| EXPECT_EQ(0u, req1->NumberOfAddresses()); |
| |
| Request* req2 = CreateRequest("localhost6", 80, MEDIUM, ADDRESS_FAMILY_IPV6); |
| EXPECT_THAT(req2->Resolve(), IsOk()); |
| EXPECT_TRUE(req2->HasOneAddress("::1", 80)); |
| |
| Request* req3 = |
| CreateRequest("localhost6", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED); |
| EXPECT_THAT(req3->Resolve(), IsOk()); |
| EXPECT_TRUE(req3->HasOneAddress("::1", 80)); |
| |
| Request* req4 = CreateRequest("localhost", 80, MEDIUM, ADDRESS_FAMILY_IPV4); |
| EXPECT_THAT(req4->Resolve(), IsOk()); |
| EXPECT_TRUE(req4->HasOneAddress("127.0.0.1", 80)); |
| |
| Request* req5 = CreateRequest("localhost", 80, MEDIUM, ADDRESS_FAMILY_IPV6); |
| EXPECT_THAT(req5->Resolve(), IsOk()); |
| EXPECT_TRUE(req5->HasOneAddress("::1", 80)); |
| } |
| |
| TEST_F(HostResolverImplTest, LocalhostIPV4IPV6Lookup_ResolveHost) { |
| HostResolver::ResolveHostParameters parameters; |
| |
| parameters.dns_query_type = HostResolver::DnsQueryType::A; |
| ResolveHostResponseHelper v6_v4_response(resolver_->CreateRequest( |
| HostPortPair("localhost6", 80), NetLogWithSource(), parameters)); |
| EXPECT_THAT(v6_v4_response.result_error(), IsOk()); |
| EXPECT_THAT(v6_v4_response.request()->GetAddressResults().value().endpoints(), |
| testing::IsEmpty()); |
| |
| parameters.dns_query_type = HostResolver::DnsQueryType::AAAA; |
| ResolveHostResponseHelper v6_v6_response(resolver_->CreateRequest( |
| HostPortPair("localhost6", 80), NetLogWithSource(), parameters)); |
| EXPECT_THAT(v6_v6_response.result_error(), IsOk()); |
| EXPECT_THAT(v6_v6_response.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("::1", 80))); |
| |
| ResolveHostResponseHelper v6_unsp_response(resolver_->CreateRequest( |
| HostPortPair("localhost6", 80), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(v6_unsp_response.result_error(), IsOk()); |
| EXPECT_THAT( |
| v6_unsp_response.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("::1", 80))); |
| |
| parameters.dns_query_type = HostResolver::DnsQueryType::A; |
| ResolveHostResponseHelper v4_v4_response(resolver_->CreateRequest( |
| HostPortPair("localhost", 80), NetLogWithSource(), parameters)); |
| EXPECT_THAT(v4_v4_response.result_error(), IsOk()); |
| EXPECT_THAT(v4_v4_response.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("127.0.0.1", 80))); |
| |
| parameters.dns_query_type = HostResolver::DnsQueryType::AAAA; |
| ResolveHostResponseHelper v4_v6_response(resolver_->CreateRequest( |
| HostPortPair("localhost", 80), NetLogWithSource(), parameters)); |
| EXPECT_THAT(v4_v6_response.result_error(), IsOk()); |
| EXPECT_THAT(v4_v6_response.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("::1", 80))); |
| |
| ResolveHostResponseHelper v4_unsp_response(resolver_->CreateRequest( |
| HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(v4_unsp_response.result_error(), IsOk()); |
| EXPECT_THAT( |
| v4_unsp_response.request()->GetAddressResults().value().endpoints(), |
| testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80), |
| CreateExpected("::1", 80))); |
| } |
| |
| TEST_F(HostResolverImplTest, ResolveIPLiteralWithHostResolverSystemOnly) { |
| const char kIpLiteral[] = "178.78.32.1"; |
| // Add a mapping to tell if the resolver proc was called (if it was called, |
| // then the result will be the remapped value. Otherwise it will be the IP |
| // literal). |
| proc_->AddRuleForAllFamilies(kIpLiteral, "183.45.32.1"); |
| |
| HostResolver::RequestInfo info_bypass(HostPortPair(kIpLiteral, 80)); |
| info_bypass.set_host_resolver_flags(HOST_RESOLVER_SYSTEM_ONLY); |
| |
| Request* req = CreateRequest(info_bypass, MEDIUM); |
| EXPECT_THAT(req->Resolve(), IsOk()); |
| |
| EXPECT_TRUE(req->HasAddress(kIpLiteral, 80)); |
| } |
| |
| TEST_F(HostResolverImplTest, |
| ResolveIPLiteralWithHostResolverSystemOnly_ResolveHost) { |
| const char kIpLiteral[] = "178.78.32.1"; |
| // Add a mapping to tell if the resolver proc was called (if it was called, |
| // then the result will be the remapped value. Otherwise it will be the IP |
| // literal). |
| proc_->AddRuleForAllFamilies(kIpLiteral, "183.45.32.1"); |
| |
| HostResolver::ResolveHostParameters parameters; |
| parameters.source = HostResolverSource::SYSTEM; |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair(kIpLiteral, 80), NetLogWithSource(), parameters)); |
| |
| // IP literal resolution is expected to take precedence over source, so the |
| // result is expected to be the input IP, not the result IP from the proc rule |
| EXPECT_THAT(response.result_error(), IsOk()); |
| EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected(kIpLiteral, 80))); |
| } |
| |
| TEST_F(HostResolverImplTest, EmptyListMeansNameNotResolved) { |
| proc_->AddRuleForAllFamilies("just.testing", ""); |
| proc_->SignalMultiple(1u); |
| |
| Request* req = CreateRequest("just.testing", 80); |
| EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(req->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED)); |
| EXPECT_EQ(0u, req->NumberOfAddresses()); |
| EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); |
| } |
| |
| TEST_F(HostResolverImplTest, EmptyListMeansNameNotResolved_ResolveHost) { |
| proc_->AddRuleForAllFamilies("just.testing", ""); |
| proc_->SignalMultiple(1u); |
| |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt)); |
| |
| EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); |
| EXPECT_FALSE(response.request()->GetAddressResults()); |
| |
| EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); |
| } |
| |
| TEST_F(HostResolverImplTest, FailedAsynchronousLookup) { |
| proc_->AddRuleForAllFamilies(std::string(), |
| "0.0.0.0"); // Default to failures. |
| proc_->SignalMultiple(1u); |
| |
| Request* req = CreateRequest("just.testing", 80); |
| EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(req->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED)); |
| |
| EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); |
| |
| // Also test that the error is not cached. |
| EXPECT_THAT(req->ResolveFromCache(), IsError(ERR_DNS_CACHE_MISS)); |
| } |
| |
| TEST_F(HostResolverImplTest, FailedAsynchronousLookup_ResolveHost) { |
| proc_->AddRuleForAllFamilies(std::string(), |
| "0.0.0.0"); // Default to failures. |
| proc_->SignalMultiple(1u); |
| |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); |
| EXPECT_FALSE(response.request()->GetAddressResults()); |
| |
| EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); |
| |
| // Also test that the error is not cached. |
| Request* req = CreateRequest("just.testing", 80); |
| EXPECT_THAT(req->ResolveFromCache(), IsError(ERR_DNS_CACHE_MISS)); |
| } |
| |
| TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) { |
| Request* req0 = CreateRequest("just.testing", 80); |
| EXPECT_THAT(req0->Resolve(), IsError(ERR_IO_PENDING)); |
| |
| EXPECT_TRUE(proc_->WaitFor(1u)); |
| |
| // Resolver is destroyed while job is running on WorkerPool. |
| resolver_.reset(); |
| |
| proc_->SignalAll(); |
| |
| // To ensure there was no spurious callback, complete with a new resolver. |
| CreateResolver(); |
| Request* req1 = CreateRequest("just.testing", 80); |
| EXPECT_THAT(req1->Resolve(), IsError(ERR_IO_PENDING)); |
| |
| proc_->SignalMultiple(2u); |
| |
| EXPECT_THAT(req1->WaitForResult(), IsOk()); |
| |
| // This request was canceled. |
| EXPECT_FALSE(req0->completed()); |
| } |
| |
| TEST_F(HostResolverImplTest, AbortedAsynchronousLookup_ResolveHost) { |
| ResolveHostResponseHelper response0(resolver_->CreateRequest( |
| HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt)); |
| ASSERT_FALSE(response0.complete()); |
| ASSERT_TRUE(proc_->WaitFor(1u)); |
| |
| // Resolver is destroyed while job is running on WorkerPool. |
| resolver_.reset(); |
| |
| proc_->SignalAll(); |
| |
| // To ensure there was no spurious callback, complete with a new resolver. |
| CreateResolver(); |
| ResolveHostResponseHelper response1(resolver_->CreateRequest( |
| HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt)); |
| |
| proc_->SignalMultiple(2u); |
| |
| EXPECT_THAT(response1.result_error(), IsOk()); |
| |
| // This request was canceled. |
| EXPECT_FALSE(response0.complete()); |
| } |
| |
| #if defined(THREAD_SANITIZER) |
| // Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140 |
| #define MAYBE_NumericIPv4Address DISABLED_NumericIPv4Address |
| #else |
| #define MAYBE_NumericIPv4Address NumericIPv4Address |
| #endif |
| TEST_F(HostResolverImplTest, MAYBE_NumericIPv4Address) { |
| // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in. |
| Request* req = CreateRequest("127.1.2.3", 5555); |
| EXPECT_THAT(req->Resolve(), IsOk()); |
| |
| EXPECT_TRUE(req->HasOneAddress("127.1.2.3", 5555)); |
| } |
| |
| #if defined(THREAD_SANITIZER) |
| // Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140 |
| #define MAYBE_NumericIPv4Address_ResolveHost \ |
| DISABLED_NumericIPv4Address_ResolveHost |
| #else |
| #define MAYBE_NumericIPv4Address_ResolveHost NumericIPv4Address_ResolveHost |
| #endif |
| TEST_F(HostResolverImplTest, MAYBE_NumericIPv4Address_ResolveHost) { |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair("127.1.2.3", 5555), NetLogWithSource(), base::nullopt)); |
| |
| EXPECT_THAT(response.result_error(), IsOk()); |
| EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("127.1.2.3", 5555))); |
| } |
| |
| #if defined(THREAD_SANITIZER) |
| // Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140 |
| #define MAYBE_NumericIPv6Address DISABLED_NumericIPv6Address |
| #else |
| #define MAYBE_NumericIPv6Address NumericIPv6Address |
| #endif |
| TEST_F(HostResolverImplTest, MAYBE_NumericIPv6Address) { |
| // Resolve a plain IPv6 address. Don't worry about [brackets], because |
| // the caller should have removed them. |
| Request* req = CreateRequest("2001:db8::1", 5555); |
| EXPECT_THAT(req->Resolve(), IsOk()); |
| |
| EXPECT_TRUE(req->HasOneAddress("2001:db8::1", 5555)); |
| } |
| |
| #if defined(THREAD_SANITIZER) |
| // Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140 |
| #define MAYBE_NumericIPv6Address_ResolveHost \ |
| DISABLED_NumericIPv6Address_ResolveHost |
| #else |
| #define MAYBE_NumericIPv6Address_ResolveHost NumericIPv6Address_ResolveHost |
| #endif |
| TEST_F(HostResolverImplTest, MAYBE_NumericIPv6Address_ResolveHost) { |
| // Resolve a plain IPv6 address. Don't worry about [brackets], because |
| // the caller should have removed them. |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair("2001:db8::1", 5555), NetLogWithSource(), base::nullopt)); |
| |
| EXPECT_THAT(response.result_error(), IsOk()); |
| EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("2001:db8::1", 5555))); |
| } |
| |
| #if defined(THREAD_SANITIZER) |
| // Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140 |
| #define MAYBE_EmptyHost DISABLED_EmptyHost |
| #else |
| #define MAYBE_EmptyHost EmptyHost |
| #endif |
| TEST_F(HostResolverImplTest, MAYBE_EmptyHost) { |
| Request* req = CreateRequest(std::string(), 5555); |
| EXPECT_THAT(req->Resolve(), IsError(ERR_NAME_NOT_RESOLVED)); |
| } |
| |
| #if defined(THREAD_SANITIZER) |
| // Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140 |
| #define MAYBE_EmptyHost_ResolveHost DISABLED_EmptyHost_ResolveHost |
| #else |
| #define MAYBE_EmptyHost_ResolveHost EmptyHost_ResolveHost |
| #endif |
| TEST_F(HostResolverImplTest, MAYBE_EmptyHost_ResolveHost) { |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair(std::string(), 5555), NetLogWithSource(), base::nullopt)); |
| |
| EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); |
| EXPECT_FALSE(response.request()->GetAddressResults()); |
| } |
| |
| #if defined(THREAD_SANITIZER) |
| // There's a data race in this test that may lead to use-after-free. |
| // If the test starts to crash without ThreadSanitizer it needs to be disabled |
| // globally. See http://crbug.com/268946 (stacks for this test in |
| // crbug.com/333567). |
| #define MAYBE_EmptyDotsHost DISABLED_EmptyDotsHost |
| #else |
| #define MAYBE_EmptyDotsHost EmptyDotsHost |
| #endif |
| TEST_F(HostResolverImplTest, MAYBE_EmptyDotsHost) { |
| for (int i = 0; i < 16; ++i) { |
| Request* req = CreateRequest(std::string(i, '.'), 5555); |
| EXPECT_THAT(req->Resolve(), IsError(ERR_NAME_NOT_RESOLVED)); |
| } |
| } |
| |
| #if defined(THREAD_SANITIZER) |
| // There's a data race in this test that may lead to use-after-free. |
| // If the test starts to crash without ThreadSanitizer it needs to be disabled |
| // globally. See http://crbug.com/268946 (stacks for this test in |
| // crbug.com/333567). |
| #define MAYBE_EmptyDotsHost_ResolveHost DISABLED_EmptyDotsHost_ResolveHost |
| #else |
| #define MAYBE_EmptyDotsHost_ResolveHost EmptyDotsHost_ResolveHost |
| #endif |
| TEST_F(HostResolverImplTest, MAYBE_EmptyDotsHost_ResolveHost) { |
| for (int i = 0; i < 16; ++i) { |
| ResolveHostResponseHelper response( |
| resolver_->CreateRequest(HostPortPair(std::string(i, '.'), 5555), |
| NetLogWithSource(), base::nullopt)); |
| |
| EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); |
| EXPECT_FALSE(response.request()->GetAddressResults()); |
| } |
| } |
| |
| #if defined(THREAD_SANITIZER) |
| // There's a data race in this test that may lead to use-after-free. |
| // If the test starts to crash without ThreadSanitizer it needs to be disabled |
| // globally. See http://crbug.com/268946. |
| #define MAYBE_LongHost DISABLED_LongHost |
| #else |
| #define MAYBE_LongHost LongHost |
| #endif |
| TEST_F(HostResolverImplTest, MAYBE_LongHost) { |
| Request* req = CreateRequest(std::string(4097, 'a'), 5555); |
| EXPECT_THAT(req->Resolve(), IsError(ERR_NAME_NOT_RESOLVED)); |
| } |
| |
| #if defined(THREAD_SANITIZER) |
| // There's a data race in this test that may lead to use-after-free. |
| // If the test starts to crash without ThreadSanitizer it needs to be disabled |
| // globally. See http://crbug.com/268946. |
| #define MAYBE_LongHost_ResolveHost DISABLED_LongHost_ResolveHost |
| #else |
| #define MAYBE_LongHost_ResolveHost LongHost_ResolveHost |
| #endif |
| TEST_F(HostResolverImplTest, MAYBE_LongHost_ResolveHost) { |
| ResolveHostResponseHelper response( |
| resolver_->CreateRequest(HostPortPair(std::string(4097, 'a'), 5555), |
| NetLogWithSource(), base::nullopt)); |
| |
| EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); |
| EXPECT_FALSE(response.request()->GetAddressResults()); |
| } |
| |
| TEST_F(HostResolverImplTest, DeDupeRequests) { |
| // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is |
| // blocked, these should all pile up until we signal it. |
| EXPECT_THAT(CreateRequest("a", 80)->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("b", 80)->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("b", 81)->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("a", 82)->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("b", 83)->Resolve(), IsError(ERR_IO_PENDING)); |
| |
| proc_->SignalMultiple(2u); // One for "a", one for "b". |
| |
| for (size_t i = 0; i < requests_.size(); ++i) { |
| EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; |
| } |
| } |
| |
| TEST_F(HostResolverImplTest, DeDupeRequests_ResolveHost) { |
| // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is |
| // blocked, these should all pile up until we signal it. |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses; |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("a", 80), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("b", 80), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("b", 81), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("a", 82), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("b", 83), NetLogWithSource(), base::nullopt))); |
| |
| for (auto& response : responses) { |
| ASSERT_FALSE(response->complete()); |
| } |
| |
| proc_->SignalMultiple(2u); // One for "a", one for "b". |
| |
| for (auto& response : responses) { |
| EXPECT_THAT(response->result_error(), IsOk()); |
| } |
| } |
| |
| TEST_F(HostResolverImplTest, CancelMultipleRequests) { |
| EXPECT_THAT(CreateRequest("a", 80)->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("b", 80)->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("b", 81)->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("a", 82)->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("b", 83)->Resolve(), IsError(ERR_IO_PENDING)); |
| |
| // Cancel everything except request for ("a", 82). |
| requests_[0]->Cancel(); |
| requests_[1]->Cancel(); |
| requests_[2]->Cancel(); |
| requests_[4]->Cancel(); |
| |
| proc_->SignalMultiple(2u); // One for "a", one for "b". |
| |
| EXPECT_THAT(requests_[3]->WaitForResult(), IsOk()); |
| } |
| |
| TEST_F(HostResolverImplTest, CancelMultipleRequests_ResolveHost) { |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses; |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("a", 80), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("b", 80), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("b", 81), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("a", 82), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("b", 83), NetLogWithSource(), base::nullopt))); |
| |
| for (auto& response : responses) { |
| ASSERT_FALSE(response->complete()); |
| } |
| |
| // Cancel everything except request for requests[3] ("a", 82). |
| responses[0]->CancelRequest(); |
| responses[1]->CancelRequest(); |
| responses[2]->CancelRequest(); |
| responses[4]->CancelRequest(); |
| |
| proc_->SignalMultiple(2u); // One for "a", one for "b". |
| |
| EXPECT_THAT(responses[3]->result_error(), IsOk()); |
| |
| EXPECT_FALSE(responses[0]->complete()); |
| EXPECT_FALSE(responses[1]->complete()); |
| EXPECT_FALSE(responses[2]->complete()); |
| EXPECT_FALSE(responses[4]->complete()); |
| } |
| |
| TEST_F(HostResolverImplTest, CanceledRequestsReleaseJobSlots) { |
| // Fill up the dispatcher and queue. |
| for (unsigned i = 0; i < kMaxJobs + 1; ++i) { |
| std::string hostname = "a_"; |
| hostname[1] = 'a' + i; |
| EXPECT_THAT(CreateRequest(hostname, 80)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest(hostname, 81)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| } |
| EXPECT_TRUE(proc_->WaitFor(kMaxJobs)); |
| |
| // Cancel all but last two. |
| for (unsigned i = 0; i < requests_.size() - 2; ++i) { |
| requests_[i]->Cancel(); |
| } |
| |
| EXPECT_TRUE(proc_->WaitFor(kMaxJobs + 1)); |
| |
| proc_->SignalAll(); |
| |
| size_t num_requests = requests_.size(); |
| EXPECT_THAT(requests_[num_requests - 1]->WaitForResult(), IsOk()); |
| EXPECT_THAT(requests_[num_requests - 2]->result(), IsOk()); |
| } |
| |
| TEST_F(HostResolverImplTest, CanceledRequestsReleaseJobSlots_ResolveHost) { |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses; |
| |
| // Fill up the dispatcher and queue. |
| for (unsigned i = 0; i < kMaxJobs + 1; ++i) { |
| std::string hostname = "a_"; |
| hostname[1] = 'a' + i; |
| |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair(hostname, 80), NetLogWithSource(), base::nullopt))); |
| ASSERT_FALSE(responses.back()->complete()); |
| |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair(hostname, 81), NetLogWithSource(), base::nullopt))); |
| ASSERT_FALSE(responses.back()->complete()); |
| } |
| |
| ASSERT_TRUE(proc_->WaitFor(kMaxJobs)); |
| |
| // Cancel all but last two. |
| for (unsigned i = 0; i < responses.size() - 2; ++i) { |
| responses[i]->CancelRequest(); |
| } |
| |
| ASSERT_TRUE(proc_->WaitFor(kMaxJobs + 1)); |
| |
| proc_->SignalAll(); |
| |
| size_t num_requests = responses.size(); |
| EXPECT_THAT(responses[num_requests - 1]->result_error(), IsOk()); |
| EXPECT_THAT(responses[num_requests - 2]->result_error(), IsOk()); |
| for (unsigned i = 0; i < num_requests - 2; ++i) { |
| EXPECT_FALSE(responses[i]->complete()); |
| } |
| } |
| |
| TEST_F(HostResolverImplTest, CancelWithinCallback) { |
| struct MyHandler : public Handler { |
| void Handle(Request* req) override { |
| // Port 80 is the first request that the callback will be invoked for. |
| // While we are executing within that callback, cancel the other requests |
| // in the job and start another request. |
| if (req->index() == 0) { |
| // Once "a:80" completes, it will cancel "a:81" and "a:82". |
| requests()[1]->Cancel(); |
| requests()[2]->Cancel(); |
| } |
| } |
| }; |
| set_handler(new MyHandler()); |
| |
| for (size_t i = 0; i < 4; ++i) { |
| EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i; |
| } |
| |
| proc_->SignalMultiple(2u); // One for "a". One for "finalrequest". |
| |
| EXPECT_THAT(requests_[0]->WaitForResult(), IsOk()); |
| |
| Request* final_request = CreateRequest("finalrequest", 70); |
| EXPECT_THAT(final_request->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(final_request->WaitForResult(), IsOk()); |
| EXPECT_TRUE(requests_[3]->completed()); |
| } |
| |
| TEST_F(HostResolverImplTest, CancelWithinCallback_ResolveHost) { |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses; |
| auto custom_callback = base::BindLambdaForTesting( |
| [&](CompletionOnceCallback completion_callback, int error) { |
| for (auto& response : responses) { |
| // Cancelling request is required to complete first, so that it can |
| // attempt to cancel the others. This test assumes all jobs are |
| // completed in order. |
| DCHECK(!response->complete()); |
| |
| response->CancelRequest(); |
| } |
| std::move(completion_callback).Run(error); |
| }); |
| |
| ResolveHostResponseHelper cancelling_response( |
| resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(), |
| base::nullopt), |
| std::move(custom_callback)); |
| |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("a", 81), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("a", 82), NetLogWithSource(), base::nullopt))); |
| |
| proc_->SignalMultiple(2u); // One for "a". One for "finalrequest". |
| |
| EXPECT_THAT(cancelling_response.result_error(), IsOk()); |
| |
| ResolveHostResponseHelper final_response(resolver_->CreateRequest( |
| HostPortPair("finalrequest", 70), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(final_response.result_error(), IsOk()); |
| |
| for (auto& response : responses) { |
| EXPECT_FALSE(response->complete()); |
| } |
| } |
| |
| TEST_F(HostResolverImplTest, DeleteWithinCallback) { |
| struct MyHandler : public Handler { |
| void Handle(Request* req) override { |
| EXPECT_EQ("a", req->info().hostname()); |
| EXPECT_EQ(80, req->info().port()); |
| |
| DeleteResolver(); |
| |
| // Quit after returning from OnCompleted (to give it a chance at |
| // incorrectly running the cancelled tasks). |
| base::ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, base::RunLoop::QuitCurrentWhenIdleClosureDeprecated()); |
| } |
| }; |
| set_handler(new MyHandler()); |
| |
| for (size_t i = 0; i < 4; ++i) { |
| EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i; |
| } |
| |
| proc_->SignalMultiple(1u); // One for "a". |
| |
| // |MyHandler| will send quit message once all the requests have finished. |
| base::RunLoop().Run(); |
| } |
| |
| TEST_F(HostResolverImplTest, DeleteWithinCallback_ResolveHost) { |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses; |
| auto custom_callback = base::BindLambdaForTesting( |
| [&](CompletionOnceCallback completion_callback, int error) { |
| for (auto& response : responses) { |
| // Deleting request is required to be first, so the other requests |
| // will still be running to be deleted. This test assumes that the |
| // Jobs will be Aborted in order and the requests in order within the |
| // jobs. |
| DCHECK(!response->complete()); |
| } |
| |
| resolver_.reset(); |
| std::move(completion_callback).Run(error); |
| }); |
| |
| ResolveHostResponseHelper deleting_response( |
| resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(), |
| base::nullopt), |
| std::move(custom_callback)); |
| |
| // Start additional requests to be cancelled as part of the first's deletion. |
| // Assumes all requests for a job are handled in order so that the deleting |
| // request will run first and cancel the rest. |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("a", 81), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("a", 82), NetLogWithSource(), base::nullopt))); |
| |
| proc_->SignalMultiple(3u); |
| |
| EXPECT_THAT(deleting_response.result_error(), IsOk()); |
| |
| base::RunLoop().RunUntilIdle(); |
| for (auto& response : responses) { |
| EXPECT_FALSE(response->complete()); |
| } |
| } |
| |
| TEST_F(HostResolverImplTest, DeleteWithinAbortedCallback) { |
| struct MyHandler : public Handler { |
| void Handle(Request* req) override { |
| EXPECT_EQ("a", req->info().hostname()); |
| EXPECT_EQ(80, req->info().port()); |
| |
| DeleteResolver(); |
| |
| // Quit after returning from OnCompleted (to give it a chance at |
| // incorrectly running the cancelled tasks). |
| base::ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, base::RunLoop::QuitCurrentWhenIdleClosureDeprecated()); |
| } |
| }; |
| set_handler(new MyHandler()); |
| |
| // This test assumes that the Jobs will be Aborted in order ["a", "b"] |
| EXPECT_THAT(CreateRequest("a", 80)->Resolve(), IsError(ERR_IO_PENDING)); |
| // HostResolverImpl will be deleted before later Requests can complete. |
| EXPECT_THAT(CreateRequest("a", 81)->Resolve(), IsError(ERR_IO_PENDING)); |
| // Job for 'b' will be aborted before it can complete. |
| EXPECT_THAT(CreateRequest("b", 82)->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("b", 83)->Resolve(), IsError(ERR_IO_PENDING)); |
| |
| EXPECT_TRUE(proc_->WaitFor(1u)); |
| |
| // Triggering an IP address change. |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| |
| // |MyHandler| will send quit message once all the requests have finished. |
| base::RunLoop().Run(); |
| |
| EXPECT_THAT(requests_[0]->result(), IsError(ERR_NETWORK_CHANGED)); |
| EXPECT_THAT(requests_[1]->result(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[2]->result(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[3]->result(), IsError(ERR_IO_PENDING)); |
| // Clean up. |
| proc_->SignalMultiple(requests_.size()); |
| } |
| |
| TEST_F(HostResolverImplTest, DeleteWithinAbortedCallback_ResolveHost) { |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses; |
| ResolveHostResponseHelper::Callback custom_callback = |
| base::BindLambdaForTesting( |
| [&](CompletionOnceCallback completion_callback, int error) { |
| for (auto& response : responses) { |
| // Deleting request is required to be first, so the other requests |
| // will still be running to be deleted. This test assumes that the |
| // Jobs will be Aborted in order and the requests in order within |
| // the jobs. |
| DCHECK(!response->complete()); |
| } |
| resolver_.reset(); |
| std::move(completion_callback).Run(error); |
| }); |
| |
| ResolveHostResponseHelper deleting_response( |
| resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(), |
| base::nullopt), |
| std::move(custom_callback)); |
| |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("a", 81), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("b", 82), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("b", 83), NetLogWithSource(), base::nullopt))); |
| |
| // Wait for all calls to queue up, trigger abort via IP address change, then |
| // signal all the queued requests to let them all try to finish. |
| EXPECT_TRUE(proc_->WaitFor(2u)); |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| proc_->SignalAll(); |
| |
| EXPECT_THAT(deleting_response.result_error(), IsError(ERR_NETWORK_CHANGED)); |
| base::RunLoop().RunUntilIdle(); |
| for (auto& response : responses) { |
| EXPECT_FALSE(response->complete()); |
| } |
| } |
| |
| TEST_F(HostResolverImplTest, StartWithinCallback) { |
| struct MyHandler : public Handler { |
| void Handle(Request* req) override { |
| if (req->index() == 0) { |
| // On completing the first request, start another request for "a". |
| // Since caching is disabled, this will result in another async request. |
| EXPECT_THAT(CreateRequest("a", 70)->Resolve(), IsError(ERR_IO_PENDING)); |
| } |
| } |
| }; |
| set_handler(new MyHandler()); |
| |
| // Turn off caching for this host resolver. |
| HostResolver::Options options = DefaultOptions(); |
| options.enable_caching = false; |
| resolver_.reset(new TestHostResolverImpl(options, NULL)); |
| resolver_->set_proc_params_for_test(DefaultParams(proc_.get())); |
| |
| for (size_t i = 0; i < 4; ++i) { |
| EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i; |
| } |
| |
| proc_->SignalMultiple(2u); // One for "a". One for the second "a". |
| |
| EXPECT_THAT(requests_[0]->WaitForResult(), IsOk()); |
| ASSERT_EQ(5u, requests_.size()); |
| EXPECT_THAT(requests_.back()->WaitForResult(), IsOk()); |
| |
| EXPECT_EQ(2u, proc_->GetCaptureList().size()); |
| } |
| |
| TEST_F(HostResolverImplTest, StartWithinCallback_ResolveHost) { |
| std::unique_ptr<ResolveHostResponseHelper> new_response; |
| auto custom_callback = base::BindLambdaForTesting( |
| [&](CompletionOnceCallback completion_callback, int error) { |
| new_response = std::make_unique<ResolveHostResponseHelper>( |
| resolver_->CreateRequest(HostPortPair("new", 70), |
| NetLogWithSource(), base::nullopt)); |
| std::move(completion_callback).Run(error); |
| }); |
| |
| ResolveHostResponseHelper starting_response( |
| resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(), |
| base::nullopt), |
| std::move(custom_callback)); |
| |
| proc_->SignalMultiple(2u); // One for "a". One for "new". |
| |
| EXPECT_THAT(starting_response.result_error(), IsOk()); |
| EXPECT_THAT(new_response->result_error(), IsOk()); |
| } |
| |
| TEST_F(HostResolverImplTest, BypassCache) { |
| struct MyHandler : public Handler { |
| void Handle(Request* req) override { |
| if (req->index() == 0) { |
| // On completing the first request, start another request for "a". |
| // Since caching is enabled, this should complete synchronously. |
| std::string hostname = req->info().hostname(); |
| EXPECT_THAT(CreateRequest(hostname, 70)->Resolve(), IsOk()); |
| EXPECT_THAT(CreateRequest(hostname, 75)->ResolveFromCache(), IsOk()); |
| |
| // Ok good. Now make sure that if we ask to bypass the cache, it can no |
| // longer service the request synchronously. |
| HostResolver::RequestInfo info(HostPortPair(hostname, 71)); |
| info.set_allow_cached_response(false); |
| EXPECT_EQ(ERR_IO_PENDING, |
| CreateRequest(info, DEFAULT_PRIORITY)->Resolve()); |
| } else if (71 == req->info().port()) { |
| // Test is done. |
| base::RunLoop::QuitCurrentWhenIdleDeprecated(); |
| } else { |
| FAIL() << "Unexpected request"; |
| } |
| } |
| }; |
| set_handler(new MyHandler()); |
| |
| EXPECT_THAT(CreateRequest("a", 80)->Resolve(), IsError(ERR_IO_PENDING)); |
| proc_->SignalMultiple(3u); // Only need two, but be generous. |
| |
| // |verifier| will send quit message once all the requests have finished. |
| base::RunLoop().Run(); |
| EXPECT_EQ(2u, proc_->GetCaptureList().size()); |
| } |
| |
| TEST_F(HostResolverImplTest, BypassCache_ResolveHost) { |
| proc_->SignalMultiple(2u); |
| |
| ResolveHostResponseHelper initial_response(resolver_->CreateRequest( |
| HostPortPair("a", 80), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(initial_response.result_error(), IsOk()); |
| EXPECT_EQ(1u, proc_->GetCaptureList().size()); |
| |
| ResolveHostResponseHelper cached_response(resolver_->CreateRequest( |
| HostPortPair("a", 80), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(cached_response.result_error(), IsOk()); |
| // Expect no increase to calls to |proc_| because result was cached. |
| EXPECT_EQ(1u, proc_->GetCaptureList().size()); |
| |
| HostResolver::ResolveHostParameters parameters; |
| parameters.allow_cached_response = false; |
| ResolveHostResponseHelper cache_bypassed_response(resolver_->CreateRequest( |
| HostPortPair("a", 80), NetLogWithSource(), parameters)); |
| EXPECT_THAT(cache_bypassed_response.result_error(), IsOk()); |
| // Expect call to |proc_| because cache was bypassed. |
| EXPECT_EQ(2u, proc_->GetCaptureList().size()); |
| } |
| |
| // Test that IP address changes flush the cache but initial DNS config reads do |
| // not. |
| TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) { |
| proc_->SignalMultiple(2u); // One before the flush, one after. |
| |
| Request* req = CreateRequest("host1", 70); |
| EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(req->WaitForResult(), IsOk()); |
| |
| req = CreateRequest("host1", 75); |
| EXPECT_THAT(req->Resolve(), IsOk()); // Should complete synchronously. |
| |
| // Verify initial DNS config read does not flush cache. |
| NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadForTests(); |
| req = CreateRequest("host1", 75); |
| EXPECT_THAT(req->Resolve(), IsOk()); // Should complete synchronously. |
| |
| // Flush cache by triggering an IP address change. |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| base::RunLoop().RunUntilIdle(); // Notification happens async. |
| |
| // Resolve "host1" again -- this time it won't be served from cache, so it |
| // will complete asynchronously. |
| req = CreateRequest("host1", 80); |
| EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(req->WaitForResult(), IsOk()); |
| } |
| |
| // Test that IP address changes flush the cache but initial DNS config reads |
| // do not. |
| TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange_ResolveHost) { |
| proc_->SignalMultiple(2u); // One before the flush, one after. |
| |
| ResolveHostResponseHelper initial_response(resolver_->CreateRequest( |
| HostPortPair("host1", 70), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(initial_response.result_error(), IsOk()); |
| EXPECT_EQ(1u, proc_->GetCaptureList().size()); |
| |
| ResolveHostResponseHelper cached_response(resolver_->CreateRequest( |
| HostPortPair("host1", 75), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(cached_response.result_error(), IsOk()); |
| EXPECT_EQ(1u, proc_->GetCaptureList().size()); // No expected increase. |
| |
| // Verify initial DNS config read does not flush cache. |
| NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadForTests(); |
| ResolveHostResponseHelper unflushed_response(resolver_->CreateRequest( |
| HostPortPair("host1", 75), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(unflushed_response.result_error(), IsOk()); |
| EXPECT_EQ(1u, proc_->GetCaptureList().size()); // No expected increase. |
| |
| // Flush cache by triggering an IP address change. |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| base::RunLoop().RunUntilIdle(); // Notification happens async. |
| |
| // Resolve "host1" again -- this time it won't be served from cache, so it |
| // will complete asynchronously. |
| ResolveHostResponseHelper flushed_response(resolver_->CreateRequest( |
| HostPortPair("host1", 80), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(flushed_response.result_error(), IsOk()); |
| EXPECT_EQ(2u, proc_->GetCaptureList().size()); // Expected increase. |
| } |
| |
| // Test that IP address changes send ERR_NETWORK_CHANGED to pending requests. |
| TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) { |
| Request* req = CreateRequest("host1", 70); |
| EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING)); |
| |
| EXPECT_TRUE(proc_->WaitFor(1u)); |
| // Triggering an IP address change. |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| base::RunLoop().RunUntilIdle(); // Notification happens async. |
| proc_->SignalAll(); |
| |
| EXPECT_THAT(req->WaitForResult(), IsError(ERR_NETWORK_CHANGED)); |
| EXPECT_EQ(0u, resolver_->GetHostCache()->size()); |
| } |
| |
| // Test that IP address changes send ERR_NETWORK_CHANGED to pending requests. |
| TEST_F(HostResolverImplTest, AbortOnIPAddressChanged_ResolveHost) { |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair("host1", 70), NetLogWithSource(), base::nullopt)); |
| |
| ASSERT_FALSE(response.complete()); |
| ASSERT_TRUE(proc_->WaitFor(1u)); |
| |
| // Triggering an IP address change. |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| base::RunLoop().RunUntilIdle(); // Notification happens async. |
| proc_->SignalAll(); |
| |
| EXPECT_THAT(response.result_error(), IsError(ERR_NETWORK_CHANGED)); |
| EXPECT_FALSE(response.request()->GetAddressResults()); |
| EXPECT_EQ(0u, resolver_->GetHostCache()->size()); |
| } |
| |
| // Test that initial DNS config read signals do not abort pending requests. |
| TEST_F(HostResolverImplTest, DontAbortOnInitialDNSConfigRead) { |
| Request* req = CreateRequest("host1", 70); |
| EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING)); |
| |
| EXPECT_TRUE(proc_->WaitFor(1u)); |
| // Triggering initial DNS config read signal. |
| NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadForTests(); |
| base::RunLoop().RunUntilIdle(); // Notification happens async. |
| proc_->SignalAll(); |
| |
| EXPECT_THAT(req->WaitForResult(), IsOk()); |
| } |
| |
| // Test that initial DNS config read signals do not abort pending requests. |
| TEST_F(HostResolverImplTest, DontAbortOnInitialDNSConfigRead_ResolveHost) { |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair("host1", 70), NetLogWithSource(), base::nullopt)); |
| |
| ASSERT_FALSE(response.complete()); |
| ASSERT_TRUE(proc_->WaitFor(1u)); |
| |
| // Triggering initial DNS config read signal. |
| NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadForTests(); |
| base::RunLoop().RunUntilIdle(); // Notification happens async. |
| proc_->SignalAll(); |
| |
| EXPECT_THAT(response.result_error(), IsOk()); |
| EXPECT_TRUE(response.request()->GetAddressResults()); |
| } |
| |
| // Obey pool constraints after IP address has changed. |
| TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) { |
| // Runs at most one job at a time. |
| CreateSerialResolver(); |
| EXPECT_THAT(CreateRequest("a")->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("b")->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("c")->Resolve(), IsError(ERR_IO_PENDING)); |
| |
| EXPECT_TRUE(proc_->WaitFor(1u)); |
| // Triggering an IP address change. |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| base::RunLoop().RunUntilIdle(); // Notification happens async. |
| proc_->SignalMultiple(3u); // Let the false-start go so that we can catch it. |
| |
| EXPECT_THAT(requests_[0]->WaitForResult(), IsError(ERR_NETWORK_CHANGED)); |
| |
| EXPECT_EQ(1u, num_running_dispatcher_jobs()); |
| |
| EXPECT_FALSE(requests_[1]->completed()); |
| EXPECT_FALSE(requests_[2]->completed()); |
| |
| EXPECT_THAT(requests_[2]->WaitForResult(), IsOk()); |
| EXPECT_THAT(requests_[1]->result(), IsOk()); |
| } |
| |
| // Obey pool constraints after IP address has changed. |
| TEST_F(HostResolverImplTest, |
| ObeyPoolConstraintsAfterIPAddressChange_ResolveHost) { |
| // Runs at most one job at a time. |
| CreateSerialResolver(); |
| |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses; |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("a", 80), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("b", 80), NetLogWithSource(), base::nullopt))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("c", 80), NetLogWithSource(), base::nullopt))); |
| |
| for (auto& response : responses) { |
| ASSERT_FALSE(response->complete()); |
| } |
| ASSERT_TRUE(proc_->WaitFor(1u)); |
| |
| // Triggering an IP address change. |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| base::RunLoop().RunUntilIdle(); // Notification happens async. |
| proc_->SignalMultiple(3u); // Let the false-start go so that we can catch it. |
| |
| // Requests should complete one at a time, with the first failing. |
| EXPECT_THAT(responses[0]->result_error(), IsError(ERR_NETWORK_CHANGED)); |
| EXPECT_EQ(1u, num_running_dispatcher_jobs()); |
| EXPECT_FALSE(responses[1]->complete()); |
| EXPECT_FALSE(responses[2]->complete()); |
| |
| EXPECT_THAT(responses[1]->result_error(), IsOk()); |
| EXPECT_EQ(1u, num_running_dispatcher_jobs()); |
| EXPECT_FALSE(responses[2]->complete()); |
| |
| EXPECT_THAT(responses[2]->result_error(), IsOk()); |
| } |
| |
| // Tests that a new Request made from the callback of a previously aborted one |
| // will not be aborted. |
| TEST_F(HostResolverImplTest, AbortOnlyExistingRequestsOnIPAddressChange) { |
| struct MyHandler : public Handler { |
| void Handle(Request* req) override { |
| // Start new request for a different hostname to ensure that the order |
| // of jobs in HostResolverImpl is not stable. |
| std::string hostname; |
| if (req->index() == 0) |
| hostname = "zzz"; |
| else if (req->index() == 1) |
| hostname = "aaa"; |
| else if (req->index() == 2) |
| hostname = "eee"; |
| else |
| return; // A request started from within MyHandler. |
| EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname)->Resolve()) << hostname; |
| } |
| }; |
| set_handler(new MyHandler()); |
| |
| EXPECT_THAT(CreateRequest("bbb")->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("eee")->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("ccc")->Resolve(), IsError(ERR_IO_PENDING)); |
| |
| // Wait until all are blocked; |
| EXPECT_TRUE(proc_->WaitFor(3u)); |
| // Trigger an IP address change. |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| // This should abort all running jobs. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_THAT(requests_[0]->result(), IsError(ERR_NETWORK_CHANGED)); |
| EXPECT_THAT(requests_[1]->result(), IsError(ERR_NETWORK_CHANGED)); |
| EXPECT_THAT(requests_[2]->result(), IsError(ERR_NETWORK_CHANGED)); |
| ASSERT_EQ(6u, requests_.size()); |
| // Unblock all calls to proc. |
| proc_->SignalMultiple(requests_.size()); |
| // Run until the re-started requests finish. |
| EXPECT_THAT(requests_[3]->WaitForResult(), IsOk()); |
| EXPECT_THAT(requests_[4]->WaitForResult(), IsOk()); |
| EXPECT_THAT(requests_[5]->WaitForResult(), IsOk()); |
| // Verify that results of aborted Jobs were not cached. |
| EXPECT_EQ(6u, proc_->GetCaptureList().size()); |
| EXPECT_EQ(3u, resolver_->GetHostCache()->size()); |
| } |
| |
| // Tests that a new Request made from the callback of a previously aborted one |
| // will not be aborted. |
| TEST_F(HostResolverImplTest, |
| AbortOnlyExistingRequestsOnIPAddressChange_ResolveHost) { |
| auto custom_callback_template = base::BindLambdaForTesting( |
| [&](const HostPortPair& next_host, |
| std::unique_ptr<ResolveHostResponseHelper>* next_response, |
| CompletionOnceCallback completion_callback, int error) { |
| *next_response = std::make_unique<ResolveHostResponseHelper>( |
| resolver_->CreateRequest(next_host, NetLogWithSource(), |
| base::nullopt)); |
| std::move(completion_callback).Run(error); |
| }); |
| |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> next_responses(3); |
| |
| ResolveHostResponseHelper response0( |
| resolver_->CreateRequest(HostPortPair("bbb", 80), NetLogWithSource(), |
| base::nullopt), |
| base::BindOnce(custom_callback_template, HostPortPair("zzz", 80), |
| &next_responses[0])); |
| |
| ResolveHostResponseHelper response1( |
| resolver_->CreateRequest(HostPortPair("eee", 80), NetLogWithSource(), |
| base::nullopt), |
| base::BindOnce(custom_callback_template, HostPortPair("aaa", 80), |
| &next_responses[1])); |
| |
| ResolveHostResponseHelper response2( |
| resolver_->CreateRequest(HostPortPair("ccc", 80), NetLogWithSource(), |
| base::nullopt), |
| base::BindOnce(custom_callback_template, HostPortPair("eee", 80), |
| &next_responses[2])); |
| |
| // Wait until all are blocked; |
| ASSERT_TRUE(proc_->WaitFor(3u)); |
| // Trigger an IP address change. |
| NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| // This should abort all running jobs. |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_THAT(response0.result_error(), IsError(ERR_NETWORK_CHANGED)); |
| EXPECT_THAT(response1.result_error(), IsError(ERR_NETWORK_CHANGED)); |
| EXPECT_THAT(response2.result_error(), IsError(ERR_NETWORK_CHANGED)); |
| |
| EXPECT_FALSE(next_responses[0]->complete()); |
| EXPECT_FALSE(next_responses[1]->complete()); |
| EXPECT_FALSE(next_responses[2]->complete()); |
| |
| // Unblock all calls to proc. |
| proc_->SignalMultiple(6u); |
| |
| // Run until the re-started requests finish. |
| EXPECT_THAT(next_responses[0]->result_error(), IsOk()); |
| EXPECT_THAT(next_responses[1]->result_error(), IsOk()); |
| EXPECT_THAT(next_responses[2]->result_error(), IsOk()); |
| |
| // Verify that results of aborted Jobs were not cached. |
| EXPECT_EQ(6u, proc_->GetCaptureList().size()); |
| EXPECT_EQ(3u, resolver_->GetHostCache()->size()); |
| } |
| |
| // Tests that when the maximum threads is set to 1, requests are dequeued |
| // in order of priority. |
| TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) { |
| CreateSerialResolver(); |
| |
| // Note that at this point the MockHostResolverProc is blocked, so any |
| // requests we make will not complete. |
| CreateRequest("req0", 80, LOW); |
| CreateRequest("req1", 80, MEDIUM); |
| CreateRequest("req2", 80, MEDIUM); |
| CreateRequest("req3", 80, LOW); |
| CreateRequest("req4", 80, HIGHEST); |
| CreateRequest("req5", 80, LOW); |
| CreateRequest("req6", 80, LOW); |
| CreateRequest("req5", 80, HIGHEST); |
| |
| for (size_t i = 0; i < requests_.size(); ++i) { |
| EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i; |
| } |
| |
| // Unblock the resolver thread so the requests can run. |
| proc_->SignalMultiple(requests_.size()); // More than needed. |
| |
| // Wait for all the requests to complete succesfully. |
| for (size_t i = 0; i < requests_.size(); ++i) { |
| EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; |
| } |
| |
| // Since we have restricted to a single concurrent thread in the jobpool, |
| // the requests should complete in order of priority (with the exception |
| // of the first request, which gets started right away, since there is |
| // nothing outstanding). |
| MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); |
| ASSERT_EQ(7u, capture_list.size()); |
| |
| EXPECT_EQ("req0", capture_list[0].hostname); |
| EXPECT_EQ("req4", capture_list[1].hostname); |
| EXPECT_EQ("req5", capture_list[2].hostname); |
| EXPECT_EQ("req1", capture_list[3].hostname); |
| EXPECT_EQ("req2", capture_list[4].hostname); |
| EXPECT_EQ("req3", capture_list[5].hostname); |
| EXPECT_EQ("req6", capture_list[6].hostname); |
| } |
| |
| // Tests that when the maximum threads is set to 1, requests are dequeued |
| // in order of priority. |
| TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst_ResolveHost) { |
| CreateSerialResolver(); |
| |
| HostResolver::ResolveHostParameters low_priority; |
| low_priority.initial_priority = LOW; |
| HostResolver::ResolveHostParameters medium_priority; |
| medium_priority.initial_priority = MEDIUM; |
| HostResolver::ResolveHostParameters highest_priority; |
| highest_priority.initial_priority = HIGHEST; |
| |
| // Note that at this point the MockHostResolverProc is blocked, so any |
| // requests we make will not complete. |
| |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses; |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req0", 80), NetLogWithSource(), low_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req1", 80), NetLogWithSource(), medium_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req2", 80), NetLogWithSource(), medium_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req3", 80), NetLogWithSource(), low_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req4", 80), NetLogWithSource(), highest_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req5", 80), NetLogWithSource(), low_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req6", 80), NetLogWithSource(), low_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req5", 80), NetLogWithSource(), highest_priority))); |
| |
| for (const auto& response : responses) { |
| ASSERT_FALSE(response->complete()); |
| } |
| |
| // Unblock the resolver thread so the requests can run. |
| proc_->SignalMultiple(responses.size()); // More than needed. |
| |
| // Wait for all the requests to complete successfully. |
| for (auto& response : responses) { |
| EXPECT_THAT(response->result_error(), IsOk()); |
| } |
| |
| // Since we have restricted to a single concurrent thread in the jobpool, |
| // the requests should complete in order of priority (with the exception |
| // of the first request, which gets started right away, since there is |
| // nothing outstanding). |
| MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); |
| ASSERT_EQ(7u, capture_list.size()); |
| |
| EXPECT_EQ("req0", capture_list[0].hostname); |
| EXPECT_EQ("req4", capture_list[1].hostname); |
| EXPECT_EQ("req5", capture_list[2].hostname); |
| EXPECT_EQ("req1", capture_list[3].hostname); |
| EXPECT_EQ("req2", capture_list[4].hostname); |
| EXPECT_EQ("req3", capture_list[5].hostname); |
| EXPECT_EQ("req6", capture_list[6].hostname); |
| } |
| |
| // Test that changing a job's priority affects the dequeueing order. |
| // TODO(crbug.com/821021): Add ResolveHost test once changing priorities is |
| // supported. |
| TEST_F(HostResolverImplTest, ChangePriority) { |
| CreateSerialResolver(); |
| |
| CreateRequest("req0", 80, MEDIUM); |
| CreateRequest("req1", 80, LOW); |
| CreateRequest("req2", 80, LOWEST); |
| |
| ASSERT_EQ(3u, requests_.size()); |
| |
| // req0 starts immediately; without ChangePriority, req1 and then req2 should |
| // run. |
| EXPECT_THAT(requests_[0]->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[1]->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[2]->Resolve(), IsError(ERR_IO_PENDING)); |
| |
| // Changing req2 to HIGH should make it run before req1. |
| // (It can't run before req0, since req0 started immediately.) |
| requests_[2]->ChangePriority(HIGHEST); |
| |
| // Let all 3 requests finish. |
| proc_->SignalMultiple(3u); |
| |
| EXPECT_THAT(requests_[0]->WaitForResult(), IsOk()); |
| EXPECT_THAT(requests_[1]->WaitForResult(), IsOk()); |
| EXPECT_THAT(requests_[2]->WaitForResult(), IsOk()); |
| |
| MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); |
| ASSERT_EQ(3u, capture_list.size()); |
| |
| EXPECT_EQ("req0", capture_list[0].hostname); |
| EXPECT_EQ("req2", capture_list[1].hostname); |
| EXPECT_EQ("req1", capture_list[2].hostname); |
| } |
| |
| // Try cancelling a job which has not started yet. |
| TEST_F(HostResolverImplTest, CancelPendingRequest) { |
| CreateSerialResolver(); |
| |
| CreateRequest("req0", 80, LOWEST); |
| CreateRequest("req1", 80, HIGHEST); // Will cancel. |
| CreateRequest("req2", 80, MEDIUM); |
| CreateRequest("req3", 80, LOW); |
| CreateRequest("req4", 80, HIGHEST); // Will cancel. |
| CreateRequest("req5", 80, LOWEST); // Will cancel. |
| CreateRequest("req6", 80, MEDIUM); |
| |
| // Start all of the requests. |
| for (size_t i = 0; i < requests_.size(); ++i) { |
| EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i; |
| } |
| |
| // Cancel some requests |
| requests_[1]->Cancel(); |
| requests_[4]->Cancel(); |
| requests_[5]->Cancel(); |
| |
| // Unblock the resolver thread so the requests can run. |
| proc_->SignalMultiple(requests_.size()); // More than needed. |
| |
| // Wait for all the requests to complete succesfully. |
| for (size_t i = 0; i < requests_.size(); ++i) { |
| if (!requests_[i]->pending()) |
| continue; // Don't wait for the requests we cancelled. |
| EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; |
| } |
| |
| // Verify that they called out the the resolver proc (which runs on the |
| // resolver thread) in the expected order. |
| MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); |
| ASSERT_EQ(4u, capture_list.size()); |
| |
| EXPECT_EQ("req0", capture_list[0].hostname); |
| EXPECT_EQ("req2", capture_list[1].hostname); |
| EXPECT_EQ("req6", capture_list[2].hostname); |
| EXPECT_EQ("req3", capture_list[3].hostname); |
| } |
| |
| // Try cancelling a job which has not started yet. |
| TEST_F(HostResolverImplTest, CancelPendingRequest_ResolveHost) { |
| CreateSerialResolver(); |
| |
| HostResolver::ResolveHostParameters lowest_priority; |
| lowest_priority.initial_priority = LOWEST; |
| HostResolver::ResolveHostParameters low_priority; |
| low_priority.initial_priority = LOW; |
| HostResolver::ResolveHostParameters medium_priority; |
| medium_priority.initial_priority = MEDIUM; |
| HostResolver::ResolveHostParameters highest_priority; |
| highest_priority.initial_priority = HIGHEST; |
| |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses; |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req0", 80), NetLogWithSource(), lowest_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req1", 80), NetLogWithSource(), highest_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req2", 80), NetLogWithSource(), medium_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req3", 80), NetLogWithSource(), low_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req4", 80), NetLogWithSource(), highest_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req5", 80), NetLogWithSource(), lowest_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req6", 80), NetLogWithSource(), medium_priority))); |
| |
| // Cancel some requests |
| responses[1]->CancelRequest(); |
| responses[4]->CancelRequest(); |
| responses[5]->CancelRequest(); |
| |
| // Unblock the resolver thread so the requests can run. |
| proc_->SignalMultiple(responses.size()); // More than needed. |
| |
| // Let everything try to finish. |
| base::RunLoop().RunUntilIdle(); |
| |
| // Wait for all the requests to complete succesfully. |
| EXPECT_THAT(responses[0]->result_error(), IsOk()); |
| EXPECT_THAT(responses[2]->result_error(), IsOk()); |
| EXPECT_THAT(responses[3]->result_error(), IsOk()); |
| EXPECT_THAT(responses[6]->result_error(), IsOk()); |
| |
| // Cancelled requests shouldn't complete. |
| EXPECT_FALSE(responses[1]->complete()); |
| EXPECT_FALSE(responses[4]->complete()); |
| EXPECT_FALSE(responses[5]->complete()); |
| |
| // Verify that they called out the the resolver proc (which runs on the |
| // resolver thread) in the expected order. |
| MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); |
| ASSERT_EQ(4u, capture_list.size()); |
| |
| EXPECT_EQ("req0", capture_list[0].hostname); |
| EXPECT_EQ("req2", capture_list[1].hostname); |
| EXPECT_EQ("req6", capture_list[2].hostname); |
| EXPECT_EQ("req3", capture_list[3].hostname); |
| } |
| |
| // Test that when too many requests are enqueued, old ones start to be aborted. |
| TEST_F(HostResolverImplTest, QueueOverflow) { |
| CreateSerialResolver(); |
| |
| // Allow only 3 queued jobs. |
| const size_t kMaxPendingJobs = 3u; |
| resolver_->SetMaxQueuedJobsForTesting(kMaxPendingJobs); |
| |
| // Note that at this point the MockHostResolverProc is blocked, so any |
| // requests we make will not complete. |
| |
| EXPECT_THAT(CreateRequest("req0", 80, LOWEST)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("req1", 80, HIGHEST)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("req2", 80, MEDIUM)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(CreateRequest("req3", 80, MEDIUM)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| |
| // At this point, there are 3 enqueued jobs. |
| // Insertion of subsequent requests will cause evictions |
| // based on priority. |
| |
| EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, |
| CreateRequest("req4", 80, LOW)->Resolve()); // Evicts itself! |
| |
| EXPECT_THAT(CreateRequest("req5", 80, MEDIUM)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[2]->result(), |
| IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)); |
| EXPECT_THAT(CreateRequest("req6", 80, HIGHEST)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[3]->result(), |
| IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)); |
| EXPECT_THAT(CreateRequest("req7", 80, MEDIUM)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[5]->result(), |
| IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)); |
| |
| // Unblock the resolver thread so the requests can run. |
| proc_->SignalMultiple(4u); |
| |
| // The rest should succeed. |
| EXPECT_THAT(requests_[7]->WaitForResult(), IsOk()); |
| EXPECT_THAT(requests_[0]->result(), IsOk()); |
| EXPECT_THAT(requests_[1]->result(), IsOk()); |
| EXPECT_THAT(requests_[6]->result(), IsOk()); |
| |
| // Verify that they called out the the resolver proc (which runs on the |
| // resolver thread) in the expected order. |
| MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); |
| ASSERT_EQ(4u, capture_list.size()); |
| |
| EXPECT_EQ("req0", capture_list[0].hostname); |
| EXPECT_EQ("req1", capture_list[1].hostname); |
| EXPECT_EQ("req6", capture_list[2].hostname); |
| EXPECT_EQ("req7", capture_list[3].hostname); |
| |
| // Verify that the evicted (incomplete) requests were not cached. |
| EXPECT_EQ(4u, resolver_->GetHostCache()->size()); |
| |
| for (size_t i = 0; i < requests_.size(); ++i) { |
| EXPECT_TRUE(requests_[i]->completed()) << i; |
| } |
| } |
| |
| // Test that when too many requests are enqueued, old ones start to be aborted. |
| TEST_F(HostResolverImplTest, QueueOverflow_ResolveHost) { |
| CreateSerialResolver(); |
| |
| // Allow only 3 queued jobs. |
| const size_t kMaxPendingJobs = 3u; |
| resolver_->SetMaxQueuedJobsForTesting(kMaxPendingJobs); |
| |
| HostResolver::ResolveHostParameters lowest_priority; |
| lowest_priority.initial_priority = LOWEST; |
| HostResolver::ResolveHostParameters low_priority; |
| low_priority.initial_priority = LOW; |
| HostResolver::ResolveHostParameters medium_priority; |
| medium_priority.initial_priority = MEDIUM; |
| HostResolver::ResolveHostParameters highest_priority; |
| highest_priority.initial_priority = HIGHEST; |
| |
| // Note that at this point the MockHostResolverProc is blocked, so any |
| // requests we make will not complete. |
| |
| std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses; |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req0", 80), NetLogWithSource(), lowest_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req1", 80), NetLogWithSource(), highest_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req2", 80), NetLogWithSource(), medium_priority))); |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req3", 80), NetLogWithSource(), medium_priority))); |
| |
| // At this point, there are 3 enqueued jobs (and one "running" job). |
| // Insertion of subsequent requests will cause evictions. |
| |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req4", 80), NetLogWithSource(), low_priority))); |
| EXPECT_THAT(responses[4]->result_error(), |
| IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)); // Evicts self. |
| EXPECT_FALSE(responses[4]->request()->GetAddressResults()); |
| |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req5", 80), NetLogWithSource(), medium_priority))); |
| EXPECT_THAT(responses[2]->result_error(), |
| IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)); |
| EXPECT_FALSE(responses[2]->request()->GetAddressResults()); |
| |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req6", 80), NetLogWithSource(), highest_priority))); |
| EXPECT_THAT(responses[3]->result_error(), |
| IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)); |
| EXPECT_FALSE(responses[3]->request()->GetAddressResults()); |
| |
| responses.emplace_back( |
| std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest( |
| HostPortPair("req7", 80), NetLogWithSource(), medium_priority))); |
| EXPECT_THAT(responses[5]->result_error(), |
| IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)); |
| EXPECT_FALSE(responses[5]->request()->GetAddressResults()); |
| |
| // Unblock the resolver thread so the requests can run. |
| proc_->SignalMultiple(4u); |
| |
| // The rest should succeed. |
| EXPECT_THAT(responses[0]->result_error(), IsOk()); |
| EXPECT_TRUE(responses[0]->request()->GetAddressResults()); |
| EXPECT_THAT(responses[1]->result_error(), IsOk()); |
| EXPECT_TRUE(responses[1]->request()->GetAddressResults()); |
| EXPECT_THAT(responses[6]->result_error(), IsOk()); |
| EXPECT_TRUE(responses[6]->request()->GetAddressResults()); |
| EXPECT_THAT(responses[7]->result_error(), IsOk()); |
| EXPECT_TRUE(responses[7]->request()->GetAddressResults()); |
| |
| // Verify that they called out the the resolver proc (which runs on the |
| // resolver thread) in the expected order. |
| MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); |
| ASSERT_EQ(4u, capture_list.size()); |
| |
| EXPECT_EQ("req0", capture_list[0].hostname); |
| EXPECT_EQ("req1", capture_list[1].hostname); |
| EXPECT_EQ("req6", capture_list[2].hostname); |
| EXPECT_EQ("req7", capture_list[3].hostname); |
| |
| // Verify that the evicted (incomplete) requests were not cached. |
| EXPECT_EQ(4u, resolver_->GetHostCache()->size()); |
| |
| for (size_t i = 0; i < responses.size(); ++i) { |
| EXPECT_TRUE(responses[i]->complete()) << i; |
| } |
| } |
| |
| // Tests that jobs can self-evict by setting the max queue to 0. |
| TEST_F(HostResolverImplTest, QueueOverflow_ResolveHost_SelfEvict) { |
| CreateSerialResolver(); |
| resolver_->SetMaxQueuedJobsForTesting(0); |
| |
| // Note that at this point the MockHostResolverProc is blocked, so any |
| // requests we make will not complete. |
| |
| ResolveHostResponseHelper run_response(resolver_->CreateRequest( |
| HostPortPair("run", 80), NetLogWithSource(), base::nullopt)); |
| |
| ResolveHostResponseHelper evict_response(resolver_->CreateRequest( |
| HostPortPair("req1", 80), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(evict_response.result_error(), |
| IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)); |
| EXPECT_FALSE(evict_response.request()->GetAddressResults()); |
| |
| proc_->SignalMultiple(1u); |
| |
| EXPECT_THAT(run_response.result_error(), IsOk()); |
| EXPECT_TRUE(run_response.request()->GetAddressResults()); |
| } |
| |
| // Make sure that the address family parameter is respected when raw IPs are |
| // passed in. |
| TEST_F(HostResolverImplTest, AddressFamilyWithRawIPs) { |
| Request* request = |
| CreateRequest("127.0.0.1", 80, MEDIUM, ADDRESS_FAMILY_IPV4); |
| EXPECT_THAT(request->Resolve(), IsOk()); |
| EXPECT_TRUE(request->HasOneAddress("127.0.0.1", 80)); |
| |
| request = CreateRequest("127.0.0.1", 80, MEDIUM, ADDRESS_FAMILY_IPV6); |
| EXPECT_THAT(request->Resolve(), IsError(ERR_NAME_NOT_RESOLVED)); |
| |
| request = CreateRequest("127.0.0.1", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED); |
| EXPECT_THAT(request->Resolve(), IsOk()); |
| EXPECT_TRUE(request->HasOneAddress("127.0.0.1", 80)); |
| |
| request = CreateRequest("::1", 80, MEDIUM, ADDRESS_FAMILY_IPV4); |
| EXPECT_THAT(request->Resolve(), IsError(ERR_NAME_NOT_RESOLVED)); |
| |
| request = CreateRequest("::1", 80, MEDIUM, ADDRESS_FAMILY_IPV6); |
| EXPECT_THAT(request->Resolve(), IsOk()); |
| EXPECT_TRUE(request->HasOneAddress("::1", 80)); |
| |
| request = CreateRequest("::1", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED); |
| EXPECT_THAT(request->Resolve(), IsOk()); |
| EXPECT_TRUE(request->HasOneAddress("::1", 80)); |
| } |
| |
| // Make sure that the dns query type parameter is respected when raw IPs are |
| // passed in. |
| TEST_F(HostResolverImplTest, AddressFamilyWithRawIPs_ResolveHost) { |
| HostResolver::ResolveHostParameters v4_parameters; |
| v4_parameters.dns_query_type = HostResolver::DnsQueryType::A; |
| |
| HostResolver::ResolveHostParameters v6_parameters; |
| v6_parameters.dns_query_type = HostResolver::DnsQueryType::AAAA; |
| |
| ResolveHostResponseHelper v4_v4_request(resolver_->CreateRequest( |
| HostPortPair("127.0.0.1", 80), NetLogWithSource(), v4_parameters)); |
| EXPECT_THAT(v4_v4_request.result_error(), IsOk()); |
| EXPECT_THAT(v4_v4_request.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("127.0.0.1", 80))); |
| |
| ResolveHostResponseHelper v4_v6_request(resolver_->CreateRequest( |
| HostPortPair("127.0.0.1", 80), NetLogWithSource(), v6_parameters)); |
| EXPECT_THAT(v4_v6_request.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); |
| |
| ResolveHostResponseHelper v4_unsp_request(resolver_->CreateRequest( |
| HostPortPair("127.0.0.1", 80), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(v4_unsp_request.result_error(), IsOk()); |
| EXPECT_THAT( |
| v4_unsp_request.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("127.0.0.1", 80))); |
| |
| ResolveHostResponseHelper v6_v4_request(resolver_->CreateRequest( |
| HostPortPair("::1", 80), NetLogWithSource(), v4_parameters)); |
| EXPECT_THAT(v6_v4_request.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); |
| |
| ResolveHostResponseHelper v6_v6_request(resolver_->CreateRequest( |
| HostPortPair("::1", 80), NetLogWithSource(), v6_parameters)); |
| EXPECT_THAT(v6_v6_request.result_error(), IsOk()); |
| EXPECT_THAT(v6_v6_request.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("::1", 80))); |
| |
| ResolveHostResponseHelper v6_unsp_request(resolver_->CreateRequest( |
| HostPortPair("::1", 80), NetLogWithSource(), base::nullopt)); |
| EXPECT_THAT(v6_unsp_request.result_error(), IsOk()); |
| EXPECT_THAT( |
| v6_unsp_request.request()->GetAddressResults().value().endpoints(), |
| testing::ElementsAre(CreateExpected("::1", 80))); |
| } |
| |
| TEST_F(HostResolverImplTest, ResolveFromCache) { |
| proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42"); |
| proc_->SignalMultiple(1u); // Need only one. |
| |
| HostResolver::RequestInfo info(HostPortPair("just.testing", 80)); |
| |
| // First query will miss the cache. |
| EXPECT_EQ(ERR_DNS_CACHE_MISS, |
| CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache()); |
| |
| // This time, we fetch normally. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[1]->WaitForResult(), IsOk()); |
| |
| // Now we should be able to fetch from the cache. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache(), |
| IsOk()); |
| EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80)); |
| } |
| |
| TEST_F(HostResolverImplTest, ResolveFromCacheInvalidName) { |
| proc_->AddRuleForAllFamilies("foo,bar.com", "192.168.1.42"); |
| |
| HostResolver::RequestInfo info(HostPortPair("foo,bar.com", 80)); |
| |
| // Query should be rejected before it makes it to the cache. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache(), |
| IsError(ERR_NAME_NOT_RESOLVED)); |
| |
| // Query should be rejected without attempting to resolve it. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->Resolve(), |
| IsError(ERR_NAME_NOT_RESOLVED)); |
| EXPECT_THAT(requests_[1]->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED)); |
| } |
| |
| TEST_F(HostResolverImplTest, ResolveFromCacheInvalidNameLocalhost) { |
| HostResolver::RequestInfo info(HostPortPair("foo,bar.localhost", 80)); |
| |
| // Query should be rejected before it makes it to the localhost check. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache(), |
| IsError(ERR_NAME_NOT_RESOLVED)); |
| |
| // Query should be rejected without attempting to resolve it. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->Resolve(), |
| IsError(ERR_NAME_NOT_RESOLVED)); |
| EXPECT_THAT(requests_[1]->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED)); |
| } |
| |
| TEST_F(HostResolverImplTest, ResolveStaleFromCache) { |
| proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42"); |
| proc_->SignalMultiple(1u); // Need only one. |
| |
| HostResolver::RequestInfo info(HostPortPair("just.testing", 80)); |
| |
| // First query will miss the cache. |
| EXPECT_EQ(ERR_DNS_CACHE_MISS, |
| CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache()); |
| |
| // This time, we fetch normally. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[1]->WaitForResult(), IsOk()); |
| |
| // Now we should be able to fetch from the cache. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache(), |
| IsOk()); |
| EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80)); |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveStaleFromCache(), |
| IsOk()); |
| EXPECT_TRUE(requests_[3]->HasOneAddress("192.168.1.42", 80)); |
| EXPECT_FALSE(requests_[3]->staleness().is_stale()); |
| |
| MakeCacheStale(); |
| |
| // Now we should be able to fetch from the cache only if we use |
| // ResolveStaleFromCache. |
| EXPECT_EQ(ERR_DNS_CACHE_MISS, |
| CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache()); |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveStaleFromCache(), |
| IsOk()); |
| EXPECT_TRUE(requests_[5]->HasOneAddress("192.168.1.42", 80)); |
| EXPECT_TRUE(requests_[5]->staleness().is_stale()); |
| } |
| |
| TEST_F(HostResolverImplTest, ResolveStaleFromCacheError) { |
| proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42"); |
| proc_->SignalMultiple(1u); // Need only one. |
| |
| HostResolver::RequestInfo info(HostPortPair("just.testing", 80)); |
| |
| // First query will miss the cache. |
| EXPECT_EQ(ERR_DNS_CACHE_MISS, |
| CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache()); |
| |
| // This time, we fetch normally. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[1]->WaitForResult(), IsOk()); |
| |
| // Now we should be able to fetch from the cache. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache(), |
| IsOk()); |
| EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80)); |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveStaleFromCache(), |
| IsOk()); |
| EXPECT_TRUE(requests_[3]->HasOneAddress("192.168.1.42", 80)); |
| EXPECT_FALSE(requests_[3]->staleness().is_stale()); |
| |
| MakeCacheStale(); |
| |
| proc_->AddRuleForAllFamilies("just.testing", ""); |
| proc_->SignalMultiple(1u); |
| |
| // Now make another query, and return an error this time. |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->Resolve(), |
| IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(requests_[4]->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED)); |
| |
| // Now we should be able to fetch from the cache only if we use |
| // ResolveStaleFromCache, and the result should be the older good result, not |
| // the error. |
| EXPECT_EQ(ERR_DNS_CACHE_MISS, |
| CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache()); |
| EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveStaleFromCache(), |
| IsOk()); |
| EXPECT_TRUE(requests_[6]->HasOneAddress("192.168.1.42", 80)); |
| EXPECT_TRUE(requests_[6]->staleness().is_stale()); |
| } |
| |
| // TODO(mgersh): add a test case for errors with positive TTL after |
| // https://crbug.com/115051 is fixed. |
| |
| // Test the retry attempts simulating host resolver proc that takes too long. |
| #if defined(STARBOARD) |
| TEST_F(HostResolverImplTest, FLAKY_MultipleAttempts) { |
| #else |
| TEST_F(HostResolverImplTest, MultipleAttempts) { |
| #endif |
| // Total number of attempts would be 3 and we want the 3rd attempt to resolve |
| // the host. First and second attempt will be forced to wait until they get |
| // word that a resolution has completed. The 3rd resolution attempt will try |
| // to get done ASAP, and won't wait. |
| int kAttemptNumberToResolve = 3; |
| int kTotalAttempts = 3; |
| |
| // Add a little bit of extra fudge to the delay to allow reasonable |
| // flexibility for time > vs >= etc. We don't need to fail the test if we |
| // retry at t=6001 instead of t=6000. |
| #if defined(STARBOARD) |
| // The 1 millisecond delay is not enough on some of Cobalt's Linux platforms |
| // to ensure all delayed tasks are executed. |
| base::TimeDelta kSleepFudgeFactor = base::TimeDelta::FromMilliseconds(30); |
| #else |
| base::TimeDelta kSleepFudgeFactor = base::TimeDelta::FromMilliseconds(1); |
| #endif |
| |
| scoped_refptr<LookupAttemptHostResolverProc> resolver_proc( |
| new LookupAttemptHostResolverProc( |
| NULL, kAttemptNumberToResolve, kTotalAttempts)); |
| |
| HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc.get()); |
| base::TimeDelta unresponsive_delay = params.unresponsive_delay; |
| int retry_factor = params.retry_factor; |
| |
| resolver_.reset(new TestHostResolverImpl(DefaultOptions(), NULL)); |
| resolver_->set_proc_params_for_test(params); |
| |
| // Override the current thread task runner, so we can simulate the passage of |
| // time and avoid any actual sleeps. |
| auto test_task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>(); |
| base::ScopedClosureRunner task_runner_override_scoped_cleanup = |
| base::ThreadTaskRunnerHandle::OverrideForTesting(test_task_runner); |
| |
| // Resolve "host1". |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair("host1", 70), NetLogWithSource(), base::nullopt)); |
| EXPECT_FALSE(response.complete()); |
| |
| resolver_proc->WaitForNAttemptsToBeBlocked(1); |
| EXPECT_FALSE(response.complete()); |
| |
| test_task_runner->FastForwardBy(unresponsive_delay + kSleepFudgeFactor); |
| resolver_proc->WaitForNAttemptsToBeBlocked(2); |
| EXPECT_FALSE(response.complete()); |
| |
| test_task_runner->FastForwardBy(unresponsive_delay * retry_factor + |
| kSleepFudgeFactor); |
| |
| resolver_proc->WaitForAllAttemptsToFinish(); |
| test_task_runner->RunUntilIdle(); |
| |
| // Resolve returns -4 to indicate that 3rd attempt has resolved the host. |
| // Since we're using a TestMockTimeTaskRunner, the RunLoop stuff in |
| // result_error() will fail if it actually has to wait, but unless there's an |
| // error, the result should be immediately ready by this point. |
| EXPECT_EQ(-4, response.result_error()); |
| |
| // We should be done with retries, but make sure none erroneously happen. |
| test_task_runner->FastForwardUntilNoTasksRemain(); |
| |
| EXPECT_EQ(resolver_proc->total_attempts_resolved(), kTotalAttempts); |
| EXPECT_EQ(resolver_proc->resolved_attempt_number(), kAttemptNumberToResolve); |
| } |
| |
| // Test the retry attempts simulating host resolver proc that takes too long. |
| TEST_F(HostResolverImplTest, MultipleAttempts_ResolveHost) { |
| // Total number of attempts would be 3 and we want the 3rd attempt to resolve |
| // the host. First and second attempt will be forced to wait until they get |
| // word that a resolution has completed. The 3rd resolution attempt will try |
| // to get done ASAP, and won't wait. |
| int kAttemptNumberToResolve = 3; |
| int kTotalAttempts = 3; |
| |
| // Add a little bit of extra fudge to the delay to allow reasonable |
| // flexibility for time > vs >= etc. We don't need to fail the test if we |
| // retry at t=6001 instead of t=6000. |
| base::TimeDelta kSleepFudgeFactor = base::TimeDelta::FromMilliseconds(1); |
| |
| scoped_refptr<LookupAttemptHostResolverProc> resolver_proc( |
| new LookupAttemptHostResolverProc(NULL, kAttemptNumberToResolve, |
| kTotalAttempts)); |
| |
| HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc.get()); |
| base::TimeDelta unresponsive_delay = params.unresponsive_delay; |
| int retry_factor = params.retry_factor; |
| |
| CreateResolverWithLimitsAndParams(kMaxJobs, params, |
| #if !defined(STARBOARD) || SB_HAS(IPV6) |
| true /* ipv6_reachable */); |
| #else |
| false /* ipv6_reachable */); |
| #endif |
| |
| // Override the current thread task runner, so we can simulate the passage of |
| // time and avoid any actual sleeps. |
| auto test_task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>(); |
| base::ScopedClosureRunner task_runner_override_scoped_cleanup = |
| base::ThreadTaskRunnerHandle::OverrideForTesting(test_task_runner); |
| |
| // Resolve "host1". |
| ResolveHostResponseHelper response(resolver_->CreateRequest( |
| HostPortPair("host1", 70), NetLogWithSource(), base::nullopt)); |
| EXPECT_FALSE(response.complete()); |
| |
| resolver_proc->WaitForNAttemptsToBeBlocked(1); |
| EXPECT_FALSE(response.complete()); |
| |
| test_task_runner->FastForwardBy(unresponsive_delay + kSleepFudgeFactor); |
| resolver_proc->WaitForNAttemptsToBeBlocked(2); |
| EXPECT_FALSE(response.complete()); |
| |
| test_task_runner->FastForwardBy(unresponsive_delay * retry_factor + |
| kSleepFudgeFactor); |
| |
| resolver_proc->WaitForAllAttemptsToFinish(); |
| test_task_runner->RunUntilIdle(); |
| |
| // Resolve returns -4 to indicate that 3rd attempt has resolved the host. |
| // Since we're using a TestMockTimeTaskRunner, the RunLoop stuff in |
| // result_error() will fail if it actually has to wait, but unless there's an |
| // error, the result should be immediately ready by this point. |
| EXPECT_EQ(-4, response.result_error()); |
| |
| // We should be done with retries, but make sure none erroneously happen. |
| test_task_runner->FastForwardUntilNoTasksRemain(); |
| |
| EXPECT_EQ(resolver_proc->total_attempts_resolved(), kTotalAttempts); |
| EXPECT_EQ(resolver_proc->resolved_attempt_number(), kAttemptNumberToResolve); |
| } |
| |
| // If a host resolves to a list that includes 127.0.53.53, this is treated as |
| // an error. 127.0.53.53 is a localhost address, however it has been given a |
| // special significance by ICANN to help surface name collision resulting from |
| // the new gTLDs. |
| TEST_F(HostResolverImplTest, NameCollisionIcann) { |
| proc_->AddRuleForAllFamilies("single", "127.0.53.53"); |
| proc_->AddRuleForAllFamilies("multiple", "127.0.0.1,127.0.53.53"); |
| #if !defined(STARBOARD) || SB_HAS(IPV6) |
| proc_->AddRuleForAllFamilies("ipv6", "::127.0.53.53"); |
| #endif |
| proc_->AddRuleForAllFamilies("not_reserved1", "53.53.0.127"); |
| proc_->AddRuleForAllFamilies("not_reserved2", "127.0.53.54"); |
| proc_->AddRuleForAllFamilies("not_reserved3", "10.0.53.53"); |
| proc_->SignalMultiple(6u); |
| |
| Request* request; |
| |
| request = CreateRequest("single"); |
| EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(request->WaitForResult(), IsError(ERR_ICANN_NAME_COLLISION)); |
| |
| // ERR_ICANN_NAME_COLLISION is cached like any other error, using a |
| // fixed TTL for failed entries from proc-based resolver. That said, the |
| // fixed TTL is 0, so it will never be cached. |
| request = CreateRequest("single"); |
| EXPECT_THAT(request->ResolveFromCache(), IsError(ERR_DNS_CACHE_MISS)); |
| |
| request = CreateRequest("multiple"); |
| EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(request->WaitForResult(), IsError(ERR_ICANN_NAME_COLLISION)); |
| |
| // Resolving an IP literal of 127.0.53.53 however is allowed. |
| EXPECT_THAT(CreateRequest("127.0.53.53")->Resolve(), IsOk()); |
| |
| #if !defined(STARBOARD) || SB_HAS(IPV6) |
| // Moreover the address should not be recognized when embedded in an IPv6 |
| // address. |
| request = CreateRequest("ipv6"); |
| EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(request->WaitForResult(), IsOk()); |
| #endif |
| |
| // Try some other IPs which are similar, but NOT an exact match on |
| // 127.0.53.53. |
| request = CreateRequest("not_reserved1"); |
| EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(request->WaitForResult(), IsOk()); |
| |
| request = CreateRequest("not_reserved2"); |
| EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(request->WaitForResult(), IsOk()); |
| |
| request = CreateRequest("not_reserved3"); |
| EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING)); |
| EXPECT_THAT(request->WaitForResult(), IsOk()); |
| |