Use context from ContextHostResolver for DoH
Had to divorce some things in HostResolver from HostCache::Key since
different requests now have different context but the cache shouldn't
be keying on context (although in a separate CL, different contexts
will soon use separate caches entirely). Jobs are now keyed on a
separate JobKey struct, and things are passed around by raw data
(hostname, query_type, etc) with HostCache::Key and JobKey generated
from that as needed rather than using any key type as a container of
request parameters.
Bug: 934402
Change-Id: Ic2d3ccd515456f25a9a09976f82dd7d277638efb
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1535148
Commit-Queue: Eric Orth <[email protected]>
Reviewed-by: Matt Menke <[email protected]>
Cr-Commit-Position: refs/heads/master@{#651326}diff --git a/net/dns/context_host_resolver.cc b/net/dns/context_host_resolver.cc
index 31a6d7e..2ce87e6 100644
--- a/net/dns/context_host_resolver.cc
+++ b/net/dns/context_host_resolver.cc
@@ -106,7 +106,9 @@
const base::Optional<ResolveHostParameters>& optional_parameters) {
// TODO(crbug.com/934402): DHCECK |context_| once universally set.
auto request = std::make_unique<WrappedRequest>(
- manager_->CreateRequest(host, source_net_log, optional_parameters), this);
+ manager_->CreateRequest(host, source_net_log, optional_parameters,
+ context_),
+ this);
active_requests_.insert(request.get());
return request;
}
diff --git a/net/dns/context_host_resolver_unittest.cc b/net/dns/context_host_resolver_unittest.cc
index 7ff08ad..cbaafd12 100644
--- a/net/dns/context_host_resolver_unittest.cc
+++ b/net/dns/context_host_resolver_unittest.cc
@@ -24,6 +24,7 @@
#include "net/log/net_log_with_source.h"
#include "net/test/gtest_util.h"
#include "net/test/test_with_scoped_task_environment.h"
+#include "net/url_request/url_request_context.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -64,18 +65,22 @@
};
TEST_F(ContextHostResolverTest, Resolve) {
+ URLRequestContext context;
+
MockDnsClientRuleList rules;
rules.emplace_back("example.com", dns_protocol::kTypeA,
SecureDnsMode::AUTOMATIC,
MockDnsClientRule::Result(BuildTestDnsResponse(
"example.com", kEndpoint.address())),
- false /* delay */);
- rules.emplace_back(
- "example.com", dns_protocol::kTypeAAAA, SecureDnsMode::AUTOMATIC,
- MockDnsClientRule::Result(MockDnsClientRule::EMPTY), false /* delay */);
+ false /* delay */, &context);
+ rules.emplace_back("example.com", dns_protocol::kTypeAAAA,
+ SecureDnsMode::AUTOMATIC,
+ MockDnsClientRule::Result(MockDnsClientRule::EMPTY),
+ false /* delay */, &context);
SetMockDnsRules(std::move(rules));
auto resolver = std::make_unique<ContextHostResolver>(manager_.get());
+ resolver->SetRequestContext(&context);
std::unique_ptr<HostResolver::ResolveHostRequest> request =
resolver->CreateRequest(HostPortPair("example.com", 100),
NetLogWithSource(), base::nullopt);
diff --git a/net/dns/host_resolver_manager.cc b/net/dns/host_resolver_manager.cc
index 1918587..0cb763a 100644
--- a/net/dns/host_resolver_manager.cc
+++ b/net/dns/host_resolver_manager.cc
@@ -21,6 +21,7 @@
#include <cmath>
#include <limits>
#include <memory>
+#include <tuple>
#include <unordered_set>
#include <utility>
@@ -82,6 +83,7 @@
#include "net/log/net_log_with_source.h"
#include "net/socket/client_socket_factory.h"
#include "net/socket/datagram_client_socket.h"
+#include "net/url_request/url_request_context.h"
#include "url/url_canon_ip.h"
#if BUILDFLAG(ENABLE_MDNS)
@@ -496,11 +498,13 @@
RequestImpl(const NetLogWithSource& source_net_log,
const HostPortPair& request_host,
const base::Optional<ResolveHostParameters>& optional_parameters,
+ URLRequestContext* request_context,
base::WeakPtr<HostResolverManager> resolver)
: source_net_log_(source_net_log),
request_host_(request_host),
parameters_(optional_parameters ? optional_parameters.value()
: ResolveHostParameters()),
+ request_context_(request_context),
host_resolver_flags_(
HostResolver::ParametersToHostResolverFlags(parameters_)),
priority_(parameters_.initial_priority),
@@ -630,6 +634,8 @@
const ResolveHostParameters& parameters() const { return parameters_; }
+ URLRequestContext* request_context() const { return request_context_; }
+
HostResolverFlags host_resolver_flags() const { return host_resolver_flags_; }
RequestPriority priority() const { return priority_; }
@@ -652,6 +658,7 @@
const HostPortPair request_host_;
const ResolveHostParameters parameters_;
+ URLRequestContext* const request_context_;
const HostResolverFlags host_resolver_flags_;
RequestPriority priority_;
@@ -694,13 +701,17 @@
typedef base::OnceCallback<void(int net_error, const AddressList& addr_list)>
Callback;
- ProcTask(const Key& key,
+ ProcTask(std::string hostname,
+ AddressFamily address_family,
+ HostResolverFlags flags,
const ProcTaskParams& params,
Callback callback,
scoped_refptr<base::TaskRunner> proc_task_runner,
const NetLogWithSource& job_net_log,
const base::TickClock* tick_clock)
- : key_(key),
+ : hostname_(std::move(hostname)),
+ address_family_(address_family),
+ flags_(flags),
params_(params),
callback_(std::move(callback)),
network_task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ -709,9 +720,6 @@
net_log_(job_net_log),
tick_clock_(tick_clock),
weak_ptr_factory_(this) {
- // ProcTask only supports resolving addresses.
- DCHECK(IsAddressType(key_.dns_query_type));
-
DCHECK(callback_);
if (!params_.resolver_proc.get())
params_.resolver_proc = HostResolverProc::GetDefault();
@@ -759,8 +767,9 @@
start_time, attempt_number_, tick_clock_);
proc_task_runner_->PostTask(
FROM_HERE,
- base::BindOnce(&ProcTask::DoLookup, key_, params_.resolver_proc,
- network_task_runner_, std::move(completion_callback)));
+ base::BindOnce(&ProcTask::DoLookup, hostname_, address_family_, flags_,
+ params_.resolver_proc, network_task_runner_,
+ std::move(completion_callback)));
net_log_.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_ATTEMPT_STARTED,
NetLog::IntCallback("attempt_number", attempt_number_));
@@ -785,16 +794,16 @@
// careful about using other objects (like MessageLoops, Singletons, etc).
// During shutdown these objects may no longer exist.
static void DoLookup(
- Key key,
+ std::string hostname,
+ AddressFamily address_family,
+ HostResolverFlags flags,
scoped_refptr<HostResolverProc> resolver_proc,
scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
AttemptCompletionCallback completion_callback) {
AddressList results;
int os_error = 0;
- int error = resolver_proc->Resolve(
- key.hostname,
- HostResolver::DnsQueryTypeToAddressFamily(key.dns_query_type),
- key.host_resolver_flags, &results, &os_error);
+ int error = resolver_proc->Resolve(std::move(hostname), address_family,
+ flags, &results, &os_error);
network_task_runner->PostTask(
FROM_HERE, base::BindOnce(std::move(completion_callback), results,
@@ -863,7 +872,9 @@
std::move(callback_).Run(error, results);
}
- Key key_;
+ const std::string hostname_;
+ const AddressFamily address_family_;
+ const HostResolverFlags flags_;
// Holds an owning reference to the HostResolverProc that we are going to use.
// This may not be the current resolver procedure by the time we call
@@ -917,7 +928,6 @@
// only needs to run one transaction.
virtual void OnFirstDnsTransactionComplete() = 0;
- virtual URLRequestContext* url_request_context() = 0;
virtual RequestPriority priority() const = 0;
protected:
@@ -926,13 +936,17 @@
};
DnsTask(DnsClient* client,
- const Key& key,
+ base::StringPiece hostname,
+ DnsQueryType query_type,
+ URLRequestContext* request_context,
bool allow_fallback_resolution,
Delegate* delegate,
const NetLogWithSource& job_net_log,
const base::TickClock* tick_clock)
: client_(client),
- key_(key),
+ hostname_(hostname),
+ query_type_(query_type),
+ request_context_(request_context),
allow_fallback_resolution_(allow_fallback_resolution),
delegate_(delegate),
net_log_(job_net_log),
@@ -946,7 +960,7 @@
bool allow_fallback_resolution() const { return allow_fallback_resolution_; }
bool needs_two_transactions() const {
- return key_.dns_query_type == DnsQueryType::UNSPECIFIED;
+ return query_type_ == DnsQueryType::UNSPECIFIED;
}
bool needs_another_transaction() const {
@@ -958,10 +972,10 @@
DCHECK(!transaction1_);
net_log_.BeginEvent(NetLogEventType::HOST_RESOLVER_IMPL_DNS_TASK);
- if (key_.dns_query_type == DnsQueryType::UNSPECIFIED) {
+ if (query_type_ == DnsQueryType::UNSPECIFIED) {
transaction1_ = CreateTransaction(DnsQueryType::A);
} else {
- transaction1_ = CreateTransaction(key_.dns_query_type);
+ transaction1_ = CreateTransaction(query_type_);
}
transaction1_->Start();
}
@@ -987,19 +1001,19 @@
// the DoH server names. This is needed to prevent infinite recursion.
DCHECK(client_->GetConfig());
for (auto& doh_server : client_->GetConfig()->dns_over_https_servers) {
- if (key_.hostname.compare(GURL(GetURLFromTemplateWithoutParameters(
- doh_server.server_template))
- .host()) == 0) {
+ if (hostname_.compare(GURL(GetURLFromTemplateWithoutParameters(
+ doh_server.server_template))
+ .host()) == 0) {
secure_dns_mode = SecureDnsMode::OFF;
}
}
std::unique_ptr<DnsTransaction> trans =
client_->GetTransactionFactory()->CreateTransaction(
- key_.hostname, DnsQueryTypeToQtype(dns_query_type),
+ hostname_, DnsQueryTypeToQtype(dns_query_type),
base::BindOnce(&DnsTask::OnTransactionComplete,
base::Unretained(this), tick_clock_->NowTicks(),
dns_query_type),
- net_log_, secure_dns_mode, delegate_->url_request_context());
+ net_log_, secure_dns_mode, request_context_);
trans->SetRequestPriority(delegate_->priority());
return trans;
}
@@ -1081,8 +1095,6 @@
if (needs_two_transactions() && num_completed_transactions_ == 1) {
saved_results_ = std::move(results);
saved_secure_ = secure;
- // No need to repeat the suffix search.
- key_.hostname = transaction->GetHostname();
delegate_->OnFirstDnsTransactionComplete();
return;
}
@@ -1370,7 +1382,9 @@
}
DnsClient* client_;
- Key key_;
+ std::string hostname_;
+ const DnsQueryType query_type_;
+ URLRequestContext* const request_context_;
// Whether resolution may fallback to other task types (e.g. ProcTask) on
// failure of this task.
@@ -1401,6 +1415,20 @@
//-----------------------------------------------------------------------------
+struct HostResolverManager::JobKey {
+ bool operator<(const JobKey& other) const {
+ return std::tie(query_type, flags, source, request_context, hostname) <
+ std::tie(other.query_type, other.flags, other.source,
+ other.request_context, other.hostname);
+ }
+
+ std::string hostname;
+ DnsQueryType query_type;
+ HostResolverFlags flags;
+ HostResolverSource source;
+ URLRequestContext* request_context;
+};
+
// Aggregates all Requests for the same Key. Dispatched via PriorityDispatch.
class HostResolverManager::Job : public PrioritizedDispatcher::Job,
public HostResolverManager::DnsTask::Delegate {
@@ -1408,13 +1436,21 @@
// Creates new job for |key| where |request_net_log| is bound to the
// request that spawned it.
Job(const base::WeakPtr<HostResolverManager>& resolver,
- const Key& key,
+ base::StringPiece hostname,
+ DnsQueryType query_type,
+ HostResolverFlags host_resolver_flags,
+ HostResolverSource requested_source,
+ URLRequestContext* request_context,
RequestPriority priority,
scoped_refptr<base::TaskRunner> proc_task_runner,
const NetLogWithSource& source_net_log,
const base::TickClock* tick_clock)
: resolver_(resolver),
- key_(key),
+ hostname_(hostname),
+ query_type_(query_type),
+ host_resolver_flags_(host_resolver_flags),
+ requested_source_(requested_source),
+ request_context_(request_context),
priority_tracker_(priority),
proc_task_runner_(std::move(proc_task_runner)),
had_non_speculative_request_(false),
@@ -1429,7 +1465,7 @@
net_log_.BeginEvent(NetLogEventType::HOST_RESOLVER_IMPL_JOB,
base::Bind(&NetLogJobCreationCallback,
- source_net_log.source(), &key_.hostname));
+ source_net_log.source(), &hostname_));
}
~Job() override {
@@ -1478,7 +1514,7 @@
}
void AddRequest(RequestImpl* request) {
- DCHECK_EQ(key_.hostname, request->request_host().host());
+ DCHECK_EQ(hostname_, request->request_host().host());
request->AssignJob(this);
@@ -1502,7 +1538,7 @@
}
void ChangeRequestPriority(RequestImpl* req, RequestPriority priority) {
- DCHECK_EQ(key_.hostname, req->request_host().host());
+ DCHECK_EQ(hostname_, req->request_host().host());
priority_tracker_.Remove(req->priority());
req->set_priority(priority);
@@ -1513,7 +1549,7 @@
// Detach cancelled request. If it was the last active Request, also finishes
// this Job.
void CancelRequest(RequestImpl* request) {
- DCHECK_EQ(key_.hostname, request->request_host().host());
+ DCHECK_EQ(hostname_, request->request_host().host());
DCHECK(!requests_.empty());
LogCancelRequest(request->source_net_log());
@@ -1584,7 +1620,7 @@
// Job must be saved in |resolver_| to be completed asynchronously.
// Otherwise the job will be destroyed with requests silently cancelled
// before completion runs.
- DCHECK_EQ(1u, resolver_->jobs_.count(key_));
+ DCHECK(self_iterator_);
base::SequencedTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(&Job::CompleteRequestsWithError,
weak_ptr_factory_.GetWeakPtr(),
@@ -1602,7 +1638,9 @@
// this Job was destroyed.
bool ServeFromHosts() {
DCHECK_GT(num_active_requests(), 0u);
- base::Optional<HostCache::Entry> results = resolver_->ServeFromHosts(key());
+ base::Optional<HostCache::Entry> results = resolver_->ServeFromHosts(
+ hostname_, query_type_,
+ host_resolver_flags_ & HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
if (results) {
// This will destroy the Job.
CompleteRequests(results.value(), base::TimeDelta(),
@@ -1612,7 +1650,16 @@
return false;
}
- const Key& key() const { return key_; }
+ void OnAddedToJobMap(JobMap::iterator iterator) {
+ DCHECK(!self_iterator_);
+ DCHECK(iterator != resolver_->jobs_.end());
+ self_iterator_ = iterator;
+ }
+
+ void OnRemovedFromJobMap() {
+ DCHECK(self_iterator_);
+ self_iterator_ = base::nullopt;
+ }
bool is_queued() const { return !handle_.is_null(); }
@@ -1621,6 +1668,13 @@
}
private:
+ HostCache::Key GenerateCacheKey(bool secure) const {
+ HostCache::Key cache_key(hostname_, query_type_, host_resolver_flags_,
+ requested_source_);
+ cache_key.secure = secure;
+ return cache_key;
+ }
+
void KillDnsTask() {
if (dns_task_) {
ReduceToOneJobSlot();
@@ -1667,7 +1721,7 @@
start_time_ = tick_clock_->NowTicks();
- switch (key_.host_resolver_source) {
+ switch (requested_source_) {
case HostResolverSource::ANY:
// Force address queries with canonname to use ProcTask to counter poor
// CNAME support in DnsTask. See https://crbug.com/872665
@@ -1676,13 +1730,13 @@
// address queries). But if hostname appears to be an MDNS name (ends in
// *.local), go with ProcTask for address queries and MdnsTask for non-
// address queries.
- if ((key_.host_resolver_flags & HOST_RESOLVER_CANONNAME) &&
- IsAddressType(key_.dns_query_type)) {
+ if ((host_resolver_flags_ & HOST_RESOLVER_CANONNAME) &&
+ IsAddressType(query_type_)) {
StartProcTask();
- } else if (!ResemblesMulticastDNSName(key_.hostname)) {
- StartDnsTask(IsAddressType(
- key_.dns_query_type) /* allow_fallback_resolution */);
- } else if (IsAddressType(key_.dns_query_type)) {
+ } else if (!ResemblesMulticastDNSName(hostname_)) {
+ StartDnsTask(
+ IsAddressType(query_type_) /* allow_fallback_resolution */);
+ } else if (IsAddressType(query_type_)) {
StartProcTask();
} else {
StartMdnsTask();
@@ -1712,10 +1766,11 @@
// PrioritizedDispatcher with tighter limits.
void StartProcTask() {
DCHECK(!is_running());
- DCHECK(IsAddressType(key_.dns_query_type));
+ DCHECK(IsAddressType(query_type_));
proc_task_ = std::make_unique<ProcTask>(
- key_, resolver_->proc_params_,
+ hostname_, HostResolver::DnsQueryTypeToAddressFamily(query_type_),
+ host_resolver_flags_, resolver_->proc_params_,
base::BindOnce(&Job::OnProcTaskComplete, base::Unretained(this),
tick_clock_->NowTicks()),
proc_task_runner_, net_log_, tick_clock_);
@@ -1769,9 +1824,9 @@
// Need to create the task even if we're going to post a failure instead of
// running it, as a "started" job needs a task to be properly cleaned up.
- dns_task_.reset(new DnsTask(resolver_->dns_client_.get(), key_,
- allow_fallback_resolution, this, net_log_,
- tick_clock_));
+ dns_task_.reset(new DnsTask(
+ resolver_->dns_client_.get(), hostname_, query_type_, request_context_,
+ allow_fallback_resolution, this, net_log_, tick_clock_));
if (resolver_->HaveDnsConfig()) {
dns_task_->StartFirstTransaction();
@@ -1884,21 +1939,21 @@
// No flags are supported for MDNS except
// HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6 (which is not actually an
// input flag).
- DCHECK_EQ(0, key_.host_resolver_flags &
+ DCHECK_EQ(0, host_resolver_flags_ &
~HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
std::vector<DnsQueryType> query_types;
- if (key_.dns_query_type == DnsQueryType::UNSPECIFIED) {
+ if (query_type_ == DnsQueryType::UNSPECIFIED) {
query_types.push_back(DnsQueryType::A);
query_types.push_back(DnsQueryType::AAAA);
} else {
- query_types.push_back(key_.dns_query_type);
+ query_types.push_back(query_type_);
}
MDnsClient* client;
int rv = resolver_->GetOrCreateMdnsClient(&client);
- mdns_task_ = std::make_unique<HostResolverMdnsTask>(client, key_.hostname,
- query_types);
+ mdns_task_ =
+ std::make_unique<HostResolverMdnsTask>(client, hostname_, query_types);
if (rv == OK) {
mdns_task_->Start(
@@ -1934,10 +1989,6 @@
CompleteRequestsWithError(rv);
}
- URLRequestContext* url_request_context() override {
- return resolver_->url_request_context_;
- }
-
void RecordJobHistograms(int error) {
// Used in UMA_HISTOGRAM_ENUMERATION. Do not renumber entries or reuse
// deprecated values.
@@ -1957,7 +2008,7 @@
if (had_non_speculative_request_) {
category = RESOLVE_SUCCESS;
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveSuccessTime", duration);
- switch (key_.dns_query_type) {
+ switch (query_type_) {
case DnsQueryType::A:
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveSuccessTime.IPV4",
duration);
@@ -1985,7 +2036,7 @@
if (had_non_speculative_request_) {
category = RESOLVE_FAIL;
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveFailureTime", duration);
- switch (key_.dns_query_type) {
+ switch (query_type_) {
case DnsQueryType::A:
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveFailureTime.IPV4",
duration);
@@ -2033,7 +2084,9 @@
// new job with the same key in case one of the OnComplete callbacks decides
// to spawn one. Consequently, if the job was owned by |jobs_|, the job
// deletes itself when CompleteRequests is done.
- std::unique_ptr<Job> self_deleter = resolver_->RemoveJob(this);
+ std::unique_ptr<Job> self_deleter;
+ if (self_iterator_)
+ self_deleter = resolver_->RemoveJob(self_iterator_.value());
if (is_running()) {
proc_task_ = nullptr;
@@ -2061,11 +2114,8 @@
bool did_complete = (results.error() != ERR_NETWORK_CHANGED) &&
(results.error() != ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);
- if (did_complete && allow_cache) {
- Key effective_key = key_;
- effective_key.secure = secure;
- resolver_->CacheResult(effective_key, results, ttl);
- }
+ if (did_complete && allow_cache)
+ resolver_->CacheResult(GenerateCacheKey(secure), results, ttl);
RecordJobHistograms(results.error());
@@ -2124,7 +2174,11 @@
base::WeakPtr<HostResolverManager> resolver_;
- Key key_;
+ const std::string hostname_;
+ const DnsQueryType query_type_;
+ const HostResolverFlags host_resolver_flags_;
+ const HostResolverSource requested_source_;
+ URLRequestContext* const request_context_;
// Tracks the highest priority across |requests_|.
PriorityTracker priority_tracker_;
@@ -2160,6 +2214,9 @@
// A handle used in |HostResolverManager::dispatcher_|.
PrioritizedDispatcher::Handle handle_;
+ // Iterator to |this| in the JobMap. |nullopt| if not owned by the JobMap.
+ base::Optional<JobMap::iterator> self_iterator_;
+
base::WeakPtrFactory<Job> weak_ptr_factory_;
};
@@ -2178,7 +2235,6 @@
additional_resolver_flags_(0),
use_proctask_by_default_(false),
allow_fallback_to_proctask_(true),
- url_request_context_(nullptr),
tick_clock_(base::DefaultTickClock::GetInstance()),
weak_ptr_factory_(this),
probe_weak_ptr_factory_(this) {
@@ -2260,9 +2316,11 @@
HostResolverManager::CreateRequest(
const HostPortPair& host,
const NetLogWithSource& net_log,
- const base::Optional<ResolveHostParameters>& optional_parameters) {
+ const base::Optional<ResolveHostParameters>& optional_parameters,
+ URLRequestContext* request_context) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
return std::make_unique<RequestImpl>(net_log, host, optional_parameters,
+ request_context,
weak_ptr_factory_.GetWeakPtr());
}
@@ -2370,14 +2428,6 @@
UpdateDNSConfig(true);
}
-void HostResolverManager::SetRequestContext(URLRequestContext* context) {
- DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-
- if (context != url_request_context_) {
- url_request_context_ = context;
- }
-}
-
const std::vector<DnsConfig::DnsOverHttpsServerConfig>*
HostResolverManager::GetDnsOverHttpsServersForTesting() const {
if (!dns_config_overrides_.dns_over_https_servers ||
@@ -2446,13 +2496,14 @@
LogStartRequest(request->source_net_log(), request->request_host());
- Key key;
+ DnsQueryType effective_query_type;
+ HostResolverFlags effective_host_resolver_flags;
base::Optional<HostCache::EntryStaleness> stale_info;
HostCache::Entry results = ResolveLocally(
request->request_host().host(), request->parameters().dns_query_type,
request->parameters().source, request->host_resolver_flags(),
- request->parameters().cache_usage, request->source_net_log(), &key,
- &stale_info);
+ request->parameters().cache_usage, request->source_net_log(),
+ &effective_query_type, &effective_host_resolver_flags, &stale_info);
if (results.error() != ERR_DNS_CACHE_MISS ||
request->parameters().source == HostResolverSource::LOCAL_ONLY) {
if (results.error() == OK && !request->parameters().is_speculative) {
@@ -2467,7 +2518,8 @@
return results.error();
}
- int rv = CreateAndStartJob(key, request);
+ int rv = CreateAndStartJob(effective_query_type,
+ effective_host_resolver_flags, request);
// At this point, expect only async or errors.
DCHECK_NE(OK, rv);
@@ -2481,7 +2533,8 @@
HostResolverFlags flags,
ResolveHostParameters::CacheUsage cache_usage,
const NetLogWithSource& source_net_log,
- Key* out_key,
+ DnsQueryType* out_effective_query_type,
+ HostResolverFlags* out_effective_host_resolver_flags,
base::Optional<HostCache::EntryStaleness>* out_stale_info) {
DCHECK(out_stale_info);
*out_stale_info = base::nullopt;
@@ -2504,12 +2557,14 @@
}
}
- // Build a key that identifies the request in the cache and in the
- // outstanding jobs map. If this key is used in the future to store an entry
- // in the cache, it will be modified first to indicate whether the result was
- // obtained securely or not.
- *out_key = GetEffectiveKeyForRequest(hostname, dns_query_type, source, flags,
- ip_address_ptr, source_net_log);
+ GetEffectiveParametersForRequest(dns_query_type, flags, ip_address_ptr,
+ source_net_log, out_effective_query_type,
+ out_effective_host_resolver_flags);
+ bool resolve_canonname =
+ *out_effective_host_resolver_flags & HOST_RESOLVER_CANONNAME;
+ bool default_family_due_to_no_ipv6 =
+ *out_effective_host_resolver_flags &
+ HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
// The result of |getaddrinfo| for empty hosts is inconsistent across systems.
// On Windows it gives the default interface's address, whereas on Linux it
@@ -2520,21 +2575,23 @@
}
base::Optional<HostCache::Entry> resolved =
- ResolveAsIP(*out_key, ip_address_ptr);
+ ResolveAsIP(*out_effective_query_type, resolve_canonname, ip_address_ptr);
if (resolved)
return resolved.value();
// Special-case localhost names, as per the recommendations in
// https://tools.ietf.org/html/draft-west-let-localhost-be-localhost.
- resolved = ServeLocalhost(*out_key);
+ resolved = ServeLocalhost(hostname, *out_effective_query_type,
+ default_family_due_to_no_ipv6);
if (resolved)
return resolved.value();
if (cache_usage == ResolveHostParameters::CacheUsage::ALLOWED ||
cache_usage == ResolveHostParameters::CacheUsage::STALE_ALLOWED) {
+ HostCache::Key key(hostname, *out_effective_query_type,
+ *out_effective_host_resolver_flags, source);
resolved = ServeFromCache(
- *out_key,
- cache_usage == ResolveHostParameters::CacheUsage::STALE_ALLOWED,
+ key, cache_usage == ResolveHostParameters::CacheUsage::STALE_ALLOWED,
out_stale_info);
if (resolved) {
DCHECK(out_stale_info->has_value());
@@ -2548,7 +2605,8 @@
// TODO(szym): Do not do this if nsswitch.conf instructs not to.
// http://crbug.com/117655
- resolved = ServeFromHosts(*out_key);
+ resolved = ServeFromHosts(hostname, *out_effective_query_type,
+ default_family_due_to_no_ipv6);
if (resolved) {
source_net_log.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_HOSTS_HIT,
resolved.value().CreateNetLogCallback());
@@ -2558,14 +2616,23 @@
return HostCache::Entry(ERR_DNS_CACHE_MISS, HostCache::Entry::SOURCE_UNKNOWN);
}
-int HostResolverManager::CreateAndStartJob(const Key& key,
- RequestImpl* request) {
+int HostResolverManager::CreateAndStartJob(
+ DnsQueryType effective_query_type,
+ HostResolverFlags effective_host_resolver_flags,
+ RequestImpl* request) {
+ JobKey key = {request->request_host().host(), effective_query_type,
+ effective_host_resolver_flags, request->parameters().source,
+ request->request_context()};
+
auto jobit = jobs_.find(key);
Job* job;
if (jobit == jobs_.end()) {
auto new_job = std::make_unique<Job>(
- weak_ptr_factory_.GetWeakPtr(), key, request->priority(),
- proc_task_runner_, request->source_net_log(), tick_clock_);
+ weak_ptr_factory_.GetWeakPtr(), request->request_host().host(),
+ effective_query_type, effective_host_resolver_flags,
+ request->parameters().source, request->request_context(),
+ request->priority(), proc_task_runner_, request->source_net_log(),
+ tick_clock_);
job = new_job.get();
new_job->Schedule(false);
DCHECK(new_job->is_running() || new_job->is_queued());
@@ -2587,8 +2654,9 @@
}
DCHECK(new_job->is_running() || new_job->is_queued());
- DCHECK(!jobs_[key]);
- jobs_[key] = std::move(new_job);
+ auto insert_result = jobs_.emplace(std::move(key), std::move(new_job));
+ DCHECK(insert_result.second);
+ job->OnAddedToJobMap(insert_result.first);
} else {
job = jobit->second.get();
}
@@ -2599,28 +2667,29 @@
}
base::Optional<HostCache::Entry> HostResolverManager::ResolveAsIP(
- const Key& key,
+ DnsQueryType query_type,
+ bool resolve_canonname,
const IPAddress* ip_address) {
- if (ip_address == nullptr || !IsAddressType(key.dns_query_type))
+ if (ip_address == nullptr || !IsAddressType(query_type))
return base::nullopt;
AddressFamily family = GetAddressFamily(*ip_address);
- if (key.dns_query_type != DnsQueryType::UNSPECIFIED &&
- key.dns_query_type != AddressFamilyToDnsQueryType(family)) {
+ if (query_type != DnsQueryType::UNSPECIFIED &&
+ query_type != AddressFamilyToDnsQueryType(family)) {
// Don't return IPv6 addresses for IPv4 queries, and vice versa.
return HostCache::Entry(ERR_NAME_NOT_RESOLVED,
HostCache::Entry::SOURCE_UNKNOWN);
}
AddressList addresses = AddressList::CreateFromIPAddress(*ip_address, 0);
- if (key.host_resolver_flags & HOST_RESOLVER_CANONNAME)
+ if (resolve_canonname)
addresses.SetDefaultCanonicalName();
return HostCache::Entry(OK, std::move(addresses),
HostCache::Entry::SOURCE_UNKNOWN);
}
base::Optional<HostCache::Entry> HostResolverManager::ServeFromCache(
- const Key& key,
+ const HostCache::Key& key,
bool allow_stale,
base::Optional<HostCache::EntryStaleness>* out_stale_info) {
DCHECK(out_stale_info);
@@ -2630,7 +2699,7 @@
return base::nullopt;
// Local-only requests search the cache for non-local-only results.
- Key effective_key = key;
+ HostCache::Key effective_key = key;
if (effective_key.host_resolver_source == HostResolverSource::LOCAL_ONLY)
effective_key.host_resolver_source = HostResolverSource::ANY;
@@ -2652,12 +2721,14 @@
}
base::Optional<HostCache::Entry> HostResolverManager::ServeFromHosts(
- const Key& key) {
- if (!HaveDnsConfig() || !IsAddressType(key.dns_query_type))
+ base::StringPiece hostname,
+ DnsQueryType query_type,
+ bool default_family_due_to_no_ipv6) {
+ if (!HaveDnsConfig() || !IsAddressType(query_type))
return base::nullopt;
// HOSTS lookups are case-insensitive.
- std::string hostname = base::ToLowerASCII(key.hostname);
+ std::string effective_hostname = base::ToLowerASCII(hostname);
const DnsHosts& hosts = dns_client_->GetConfig()->hosts;
@@ -2667,30 +2738,24 @@
// We prefer IPv6 because "happy eyeballs" will fall back to IPv4 if
// necessary.
AddressList addresses;
- if (key.dns_query_type == DnsQueryType::AAAA ||
- key.dns_query_type == DnsQueryType::UNSPECIFIED) {
- auto it = hosts.find(DnsHostsKey(hostname, ADDRESS_FAMILY_IPV6));
+ if (query_type == DnsQueryType::AAAA ||
+ query_type == DnsQueryType::UNSPECIFIED) {
+ auto it = hosts.find(DnsHostsKey(effective_hostname, ADDRESS_FAMILY_IPV6));
if (it != hosts.end())
addresses.push_back(IPEndPoint(it->second, 0));
}
- if (key.dns_query_type == DnsQueryType::A ||
- key.dns_query_type == DnsQueryType::UNSPECIFIED) {
- auto it = hosts.find(DnsHostsKey(hostname, ADDRESS_FAMILY_IPV4));
+ if (query_type == DnsQueryType::A ||
+ query_type == DnsQueryType::UNSPECIFIED) {
+ auto it = hosts.find(DnsHostsKey(effective_hostname, ADDRESS_FAMILY_IPV4));
if (it != hosts.end())
addresses.push_back(IPEndPoint(it->second, 0));
}
// If got only loopback addresses and the family was restricted, resolve
// again, without restrictions. See SystemHostResolverCall for rationale.
- if ((key.host_resolver_flags &
- HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6) &&
- IsAllIPv4Loopback(addresses)) {
- Key new_key(key);
- new_key.dns_query_type = DnsQueryType::UNSPECIFIED;
- new_key.host_resolver_flags &=
- ~HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
- return ServeFromHosts(new_key);
+ if (default_family_due_to_no_ipv6 && IsAllIPv4Loopback(addresses)) {
+ return ServeFromHosts(hostname, DnsQueryType::UNSPECIFIED, false);
}
if (!addresses.empty()) {
@@ -2702,10 +2767,12 @@
}
base::Optional<HostCache::Entry> HostResolverManager::ServeLocalhost(
- const Key& key) {
+ base::StringPiece hostname,
+ DnsQueryType query_type,
+ bool default_family_due_to_no_ipv6) {
AddressList resolved_addresses;
- if (!IsAddressType(key.dns_query_type) ||
- !ResolveLocalHostname(key.hostname, &resolved_addresses)) {
+ if (!IsAddressType(query_type) ||
+ !ResolveLocalHostname(hostname, &resolved_addresses)) {
return base::nullopt;
}
@@ -2717,13 +2784,11 @@
// - this is an IPv6 address and caller specifically asked for IPv4 due
// to lack of detected IPv6 support. (See SystemHostResolverCall for
// rationale).
- if (key.dns_query_type == DnsQueryType::UNSPECIFIED ||
- HostResolver::DnsQueryTypeToAddressFamily(key.dns_query_type) ==
+ if (query_type == DnsQueryType::UNSPECIFIED ||
+ HostResolver::DnsQueryTypeToAddressFamily(query_type) ==
address.GetFamily() ||
(address.GetFamily() == ADDRESS_FAMILY_IPV6 &&
- key.dns_query_type == DnsQueryType::A &&
- (key.host_resolver_flags &
- HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6))) {
+ query_type == DnsQueryType::A && default_family_due_to_no_ipv6)) {
filtered_addresses.push_back(address);
}
}
@@ -2732,7 +2797,7 @@
HostCache::Entry::SOURCE_UNKNOWN);
}
-void HostResolverManager::CacheResult(const Key& key,
+void HostResolverManager::CacheResult(const HostCache::Key& key,
const HostCache::Entry& entry,
base::TimeDelta ttl) {
// Don't cache an error unless it has a positive TTL.
@@ -2774,29 +2839,31 @@
}
std::unique_ptr<HostResolverManager::Job> HostResolverManager::RemoveJob(
- Job* job) {
- DCHECK(job);
- std::unique_ptr<Job> retval;
- auto it = jobs_.find(job->key());
- if (it != jobs_.end() && it->second.get() == job) {
- it->second.swap(retval);
- jobs_.erase(it);
- }
- return retval;
+ JobMap::iterator job_it) {
+ DCHECK(job_it != jobs_.end());
+ DCHECK(job_it->second);
+ DCHECK_EQ(1u, jobs_.count(job_it->first));
+
+ std::unique_ptr<Job> job;
+ job_it->second.swap(job);
+ jobs_.erase(job_it);
+ job->OnRemovedFromJobMap();
+
+ return job;
}
-HostResolverManager::Key HostResolverManager::GetEffectiveKeyForRequest(
- const std::string& hostname,
+void HostResolverManager::GetEffectiveParametersForRequest(
DnsQueryType dns_query_type,
- HostResolverSource source,
HostResolverFlags flags,
const IPAddress* ip_address,
- const NetLogWithSource& net_log) {
- HostResolverFlags effective_flags = flags | additional_resolver_flags_;
+ const NetLogWithSource& net_log,
+ DnsQueryType* out_effective_type,
+ HostResolverFlags* out_effective_flags) {
+ *out_effective_flags = flags | additional_resolver_flags_;
- DnsQueryType effective_query_type = dns_query_type;
+ *out_effective_type = dns_query_type;
- if (effective_query_type == DnsQueryType::UNSPECIFIED &&
+ if (*out_effective_type == DnsQueryType::UNSPECIFIED &&
// When resolving IPv4 literals, there's no need to probe for IPv6.
// When resolving IPv6 literals, there's no benefit to artificially
// limiting our resolution based on a probe. Prior logic ensures
@@ -2804,11 +2871,9 @@
// so the code requesting the resolution should be amenable to receiving a
// IPv6 resolution.
!use_local_ipv6_ && ip_address == nullptr && !IsIPv6Reachable(net_log)) {
- effective_query_type = DnsQueryType::A;
- effective_flags |= HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
+ *out_effective_type = DnsQueryType::A;
+ *out_effective_flags |= HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
}
-
- return Key(hostname, effective_query_type, effective_flags, source);
}
bool HostResolverManager::IsIPv6Reachable(const NetLogWithSource& net_log) {
@@ -2881,8 +2946,7 @@
for (auto it = jobs_.begin(); it != jobs_.end();) {
Job* job = it->second.get();
if (job->is_running()) {
- jobs_to_abort.push_back(std::move(it->second));
- jobs_.erase(it++);
+ jobs_to_abort.push_back(RemoveJob(it++));
} else {
DCHECK(job->is_queued());
++it;
diff --git a/net/dns/host_resolver_manager.h b/net/dns/host_resolver_manager.h
index fc6d3747..488690c0 100644
--- a/net/dns/host_resolver_manager.h
+++ b/net/dns/host_resolver_manager.h
@@ -25,7 +25,6 @@
#include "net/dns/host_resolver.h"
#include "net/dns/host_resolver_proc.h"
#include "net/dns/public/dns_query_type.h"
-#include "net/url_request/url_request_context.h"
#include "url/gurl.h"
namespace base {
@@ -42,6 +41,7 @@
class MDnsSocketFactory;
class NetLog;
class NetLogWithSource;
+class URLRequestContext;
// Scheduler and controller of host resolution requests. Because of the global
// nature of host resolutions, this class is generally expected to be singleton
@@ -122,7 +122,8 @@
std::unique_ptr<CancellableRequest> CreateRequest(
const HostPortPair& host,
const NetLogWithSource& net_log,
- const base::Optional<ResolveHostParameters>& optional_parameters);
+ const base::Optional<ResolveHostParameters>& optional_parameters,
+ URLRequestContext* request_context);
std::unique_ptr<MdnsListener> CreateMdnsListener(const HostPortPair& host,
DnsQueryType query_type);
void SetDnsClientEnabled(bool enabled);
@@ -146,7 +147,6 @@
void SetDnsConfigOverrides(const DnsConfigOverrides& overrides);
- void SetRequestContext(URLRequestContext* request_context);
const std::vector<DnsConfig::DnsOverHttpsServerConfig>*
GetDnsOverHttpsServersForTesting() const;
@@ -186,12 +186,12 @@
friend class HostResolverManagerTest;
FRIEND_TEST_ALL_PREFIXES(HostResolverManagerDnsTest, ModeForHistogram);
class Job;
+ struct JobKey;
class ProcTask;
class LoopbackProbeJob;
class DnsTask;
class RequestImpl;
- using Key = HostCache::Key;
- using JobMap = std::map<Key, std::unique_ptr<Job>>;
+ using JobMap = std::map<JobKey, std::unique_ptr<Job>>;
// Current resolver mode, useful for breaking down histograms.
enum ModeForHistogram {
@@ -223,8 +223,8 @@
// or ERR_DNS_CACHE_MISS if the host could not be resolved using local
// sources.
//
- // On ERR_DNS_CACHE_MISS and OK, the cache key for the request is written to
- // |out_key|. On other errors, it may not be.
+ // On ERR_DNS_CACHE_MISS and OK, effective request parameters are written to
+ // |out_effective_query_type| and |out_effective_host_resolver_flags|.
//
// If results are returned from the host cache, |out_stale_info| will be
// filled in with information on how stale or fresh the result is. Otherwise,
@@ -239,17 +239,21 @@
HostResolverFlags flags,
ResolveHostParameters::CacheUsage cache_usage,
const NetLogWithSource& request_net_log,
- Key* out_key,
+ DnsQueryType* out_effective_query_type,
+ HostResolverFlags* out_effective_host_resolver_flags,
base::Optional<HostCache::EntryStaleness>* out_stale_info);
// Attempts to create and start a Job to asynchronously attempt to resolve
- // |key|. On success, returns ERR_IO_PENDING and attaches the Job to
+ // |request|. On success, returns ERR_IO_PENDING and attaches the Job to
// |request|. On error, marks |request| completed and returns the error.
- int CreateAndStartJob(const Key& key, RequestImpl* request);
+ int CreateAndStartJob(DnsQueryType effective_query_type,
+ HostResolverFlags effective_host_resolver_flags,
+ RequestImpl* request);
// Tries to resolve |key| and its possible IP address representation,
// |ip_address|. Returns a results entry iff the input can be resolved.
- base::Optional<HostCache::Entry> ResolveAsIP(const Key& key,
+ base::Optional<HostCache::Entry> ResolveAsIP(DnsQueryType query_type,
+ bool resolve_canonname,
const IPAddress* ip_address);
// Returns the result iff a positive match is found for |key| in the cache.
@@ -259,27 +263,32 @@
//
// If |allow_stale| is true, then stale cache entries can be returned.
base::Optional<HostCache::Entry> ServeFromCache(
- const Key& key,
+ const HostCache::Key& key,
bool allow_stale,
base::Optional<HostCache::EntryStaleness>* out_stale_info);
// Iff we have a DnsClient with a valid DnsConfig, and |key| can be resolved
// from the HOSTS file, return the results.
- base::Optional<HostCache::Entry> ServeFromHosts(const Key& key);
+ base::Optional<HostCache::Entry> ServeFromHosts(
+ base::StringPiece hostname,
+ DnsQueryType query_type,
+ bool default_family_due_to_no_ipv6);
// Iff |key| is for a localhost name (RFC 6761) and address DNS query type,
// returns a results entry with the loopback IP.
- base::Optional<HostCache::Entry> ServeLocalhost(const Key& key);
+ base::Optional<HostCache::Entry> ServeLocalhost(
+ base::StringPiece hostname,
+ DnsQueryType query_type,
+ bool default_family_due_to_no_ipv6);
- // Returns the (hostname, address_family) key to use for |info|, choosing an
- // "effective" address family by inheriting the resolver's default address
- // family when the request leaves it unspecified.
- Key GetEffectiveKeyForRequest(const std::string& hostname,
- DnsQueryType dns_query_type,
- HostResolverSource source,
- HostResolverFlags flags,
- const IPAddress* ip_address,
- const NetLogWithSource& net_log);
+ // Determines "effective" request parameters using manager properties and IPv6
+ // reachability.
+ void GetEffectiveParametersForRequest(DnsQueryType dns_query_type,
+ HostResolverFlags flags,
+ const IPAddress* ip_address,
+ const NetLogWithSource& net_log,
+ DnsQueryType* out_effective_type,
+ HostResolverFlags* out_effective_flags);
// Probes IPv6 support and returns true if IPv6 support is enabled.
// Results are cached, i.e. when called repeatedly this method returns result
@@ -294,7 +303,7 @@
virtual void RunLoopbackProbeJob();
// Records the result in cache if cache is present.
- void CacheResult(const Key& key,
+ void CacheResult(const HostCache::Key& key,
const HostCache::Entry& entry,
base::TimeDelta ttl);
@@ -303,8 +312,8 @@
bool from_cache,
base::TimeDelta duration) const;
- // Removes |job| from |jobs_| and return, only if it exists.
- std::unique_ptr<Job> RemoveJob(Job* job);
+ // Removes |job_it| from |jobs_| and return.
+ std::unique_ptr<Job> RemoveJob(JobMap::iterator job_it);
// Aborts all in progress jobs with ERR_NETWORK_CHANGED and notifies their
// requests. Might start new jobs.
@@ -423,8 +432,6 @@
// Current resolver mode, useful for breaking down histogram data.
ModeForHistogram mode_for_histogram_;
- URLRequestContext* url_request_context_;
-
// Shared tick clock, overridden for testing.
const base::TickClock* tick_clock_;
diff --git a/net/dns/host_resolver_manager_unittest.cc b/net/dns/host_resolver_manager_unittest.cc
index d9b620d..1fc4c71f 100644
--- a/net/dns/host_resolver_manager_unittest.cc
+++ b/net/dns/host_resolver_manager_unittest.cc
@@ -52,6 +52,8 @@
#include "net/log/test_net_log.h"
#include "net/test/gtest_util.h"
#include "net/test/test_with_scoped_task_environment.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_test_util.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -485,7 +487,10 @@
protected:
// testing::Test implementation:
- void SetUp() override { CreateResolver(); }
+ void SetUp() override {
+ CreateResolver();
+ request_context_ = std::make_unique<TestURLRequestContext>();
+ }
void TearDown() override {
if (resolver_.get())
@@ -543,6 +548,7 @@
scoped_refptr<MockHostResolverProc> proc_;
std::unique_ptr<HostResolverManager> resolver_;
+ std::unique_ptr<URLRequestContext> request_context_;
};
TEST_F(HostResolverManagerTest, AsynchronousLookup) {
@@ -550,7 +556,8 @@
proc_->SignalMultiple(1u);
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
@@ -566,6 +573,65 @@
EXPECT_TRUE(cache_result);
}
+TEST_F(HostResolverManagerTest, JobsClearedOnCompletion) {
+ proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
+ proc_->SignalMultiple(1u);
+
+ ResolveHostResponseHelper response(resolver_->CreateRequest(
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
+ EXPECT_EQ(1u, resolver_->num_jobs_for_testing());
+
+ EXPECT_THAT(response.result_error(), IsOk());
+ EXPECT_EQ(0u, resolver_->num_jobs_for_testing());
+}
+
+TEST_F(HostResolverManagerTest, JobsClearedOnCompletion_MultipleRequests) {
+ proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
+ proc_->SignalMultiple(1u);
+
+ ResolveHostResponseHelper response1(resolver_->CreateRequest(
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
+ ResolveHostResponseHelper response2(resolver_->CreateRequest(
+ HostPortPair("just.testing", 85), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
+ EXPECT_EQ(1u, resolver_->num_jobs_for_testing());
+
+ EXPECT_THAT(response1.result_error(), IsOk());
+ EXPECT_THAT(response2.result_error(), IsOk());
+ EXPECT_EQ(0u, resolver_->num_jobs_for_testing());
+}
+
+TEST_F(HostResolverManagerTest, JobsClearedOnCompletion_Failure) {
+ 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,
+ request_context_.get()));
+ EXPECT_EQ(1u, resolver_->num_jobs_for_testing());
+
+ EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
+ EXPECT_EQ(0u, resolver_->num_jobs_for_testing());
+}
+
+TEST_F(HostResolverManagerTest, JobsClearedOnCompletion_Abort) {
+ proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
+
+ ResolveHostResponseHelper response(resolver_->CreateRequest(
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
+ EXPECT_EQ(1u, resolver_->num_jobs_for_testing());
+
+ NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
+ proc_->SignalMultiple(1u);
+
+ EXPECT_THAT(response.result_error(), IsError(ERR_NETWORK_CHANGED));
+ EXPECT_EQ(0u, resolver_->num_jobs_for_testing());
+}
+
TEST_F(HostResolverManagerTest, DnsQueryType) {
proc_->AddRule("host", ADDRESS_FAMILY_IPV4, "192.168.1.20");
proc_->AddRule("host", ADDRESS_FAMILY_IPV6, "::5");
@@ -573,12 +639,14 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::A;
- ResolveHostResponseHelper v4_response(resolver_->CreateRequest(
- HostPortPair("host", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper v4_response(
+ resolver_->CreateRequest(HostPortPair("host", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
parameters.dns_query_type = DnsQueryType::AAAA;
- ResolveHostResponseHelper v6_response(resolver_->CreateRequest(
- HostPortPair("host", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper v6_response(
+ resolver_->CreateRequest(HostPortPair("host", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
proc_->SignalMultiple(2u);
@@ -596,20 +664,23 @@
parameters.dns_query_type = DnsQueryType::A;
ResolveHostResponseHelper v6_v4_response(resolver_->CreateRequest(
- HostPortPair("localhost6", 80), NetLogWithSource(), parameters));
+ HostPortPair("localhost6", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
EXPECT_THAT(v6_v4_response.result_error(), IsOk());
EXPECT_THAT(v6_v4_response.request()->GetAddressResults().value().endpoints(),
testing::IsEmpty());
parameters.dns_query_type = DnsQueryType::AAAA;
ResolveHostResponseHelper v6_v6_response(resolver_->CreateRequest(
- HostPortPair("localhost6", 80), NetLogWithSource(), parameters));
+ HostPortPair("localhost6", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
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));
+ HostPortPair("localhost6", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(v6_unsp_response.result_error(), IsOk());
EXPECT_THAT(
v6_unsp_response.request()->GetAddressResults().value().endpoints(),
@@ -617,20 +688,23 @@
parameters.dns_query_type = DnsQueryType::A;
ResolveHostResponseHelper v4_v4_response(resolver_->CreateRequest(
- HostPortPair("localhost", 80), NetLogWithSource(), parameters));
+ HostPortPair("localhost", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
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 = DnsQueryType::AAAA;
ResolveHostResponseHelper v4_v6_response(resolver_->CreateRequest(
- HostPortPair("localhost", 80), NetLogWithSource(), parameters));
+ HostPortPair("localhost", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
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));
+ HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(v4_unsp_response.result_error(), IsOk());
EXPECT_THAT(
v4_unsp_response.request()->GetAddressResults().value().endpoints(),
@@ -647,8 +721,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.source = HostResolverSource::SYSTEM;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair(kIpLiteral, 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair(kIpLiteral, 80), NetLogWithSource(),
+ parameters, request_context_.get()));
// 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
@@ -663,7 +738,8 @@
proc_->SignalMultiple(1u);
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
@@ -678,7 +754,8 @@
proc_->SignalMultiple(1u);
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetStaleInfo());
@@ -695,7 +772,8 @@
TEST_F(HostResolverManagerTest, AbortedAsynchronousLookup) {
ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
ASSERT_FALSE(response0.complete());
ASSERT_TRUE(proc_->WaitFor(1u));
@@ -707,7 +785,8 @@
// To ensure there was no spurious callback, complete with a new resolver.
CreateResolver();
ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
proc_->SignalMultiple(2u);
@@ -719,7 +798,8 @@
TEST_F(HostResolverManagerTest, NumericIPv4Address) {
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("127.1.2.3", 5555), NetLogWithSource(), base::nullopt));
+ HostPortPair("127.1.2.3", 5555), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
@@ -730,7 +810,8 @@
// 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));
+ HostPortPair("2001:db8::1", 5555), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
@@ -739,7 +820,8 @@
TEST_F(HostResolverManagerTest, EmptyHost) {
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair(std::string(), 5555), NetLogWithSource(), base::nullopt));
+ HostPortPair(std::string(), 5555), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
@@ -747,9 +829,9 @@
TEST_F(HostResolverManagerTest, EmptyDotsHost) {
for (int i = 0; i < 16; ++i) {
- ResolveHostResponseHelper response(
- resolver_->CreateRequest(HostPortPair(std::string(i, '.'), 5555),
- NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(resolver_->CreateRequest(
+ HostPortPair(std::string(i, '.'), 5555), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
@@ -757,9 +839,9 @@
}
TEST_F(HostResolverManagerTest, LongHost) {
- ResolveHostResponseHelper response(
- resolver_->CreateRequest(HostPortPair(std::string(4097, 'a'), 5555),
- NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(resolver_->CreateRequest(
+ HostPortPair(std::string(4097, 'a'), 5555), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
@@ -769,21 +851,21 @@
// 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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("b", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("b", 81), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("a", 82), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("b", 83), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
for (auto& response : responses) {
ASSERT_FALSE(response->complete());
@@ -798,21 +880,21 @@
TEST_F(HostResolverManagerTest, CancelMultipleRequests) {
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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("b", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("b", 81), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("a", 82), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("b", 83), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
for (auto& response : responses) {
ASSERT_FALSE(response->complete());
@@ -842,14 +924,14 @@
std::string hostname = "a_";
hostname[1] = 'a' + i;
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair(hostname, 80), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair(hostname, 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
ASSERT_FALSE(responses.back()->complete());
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair(hostname, 81), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair(hostname, 81), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
ASSERT_FALSE(responses.back()->complete());
}
@@ -889,22 +971,23 @@
ResolveHostResponseHelper cancelling_response(
resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(),
- base::nullopt),
+ base::nullopt, request_context_.get()),
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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("a", 81), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("a", 82), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
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));
+ HostPortPair("finalrequest", 70), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(final_response.result_error(), IsOk());
for (auto& response : responses) {
@@ -930,18 +1013,18 @@
ResolveHostResponseHelper deleting_response(
resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(),
- base::nullopt),
+ base::nullopt, request_context_.get()),
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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("a", 81), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("a", 82), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
proc_->SignalMultiple(3u);
@@ -977,18 +1060,18 @@
ResolveHostResponseHelper deleting_response(
resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(),
- base::nullopt),
+ base::nullopt, request_context_.get()),
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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("a", 81), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("b", 82), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("b", 83), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
// 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.
@@ -1009,13 +1092,14 @@
[&](CompletionOnceCallback completion_callback, int error) {
new_response = std::make_unique<ResolveHostResponseHelper>(
resolver_->CreateRequest(HostPortPair("new", 70),
- NetLogWithSource(), base::nullopt));
+ NetLogWithSource(), base::nullopt,
+ request_context_.get()));
std::move(completion_callback).Run(error);
});
ResolveHostResponseHelper starting_response(
resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(),
- base::nullopt),
+ base::nullopt, request_context_.get()),
std::move(custom_callback));
proc_->SignalMultiple(2u); // One for "a". One for "new".
@@ -1033,23 +1117,27 @@
[&](CompletionOnceCallback completion_callback, int error) {
new_response = std::make_unique<ResolveHostResponseHelper>(
resolver_->CreateRequest(HostPortPair("new", 70),
- NetLogWithSource(), base::nullopt));
+ NetLogWithSource(), base::nullopt,
+ request_context_.get()));
std::move(completion_callback).Run(error);
});
- ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
- HostPortPair("initial", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper initial_response(
+ resolver_->CreateRequest(HostPortPair("initial", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ResolveHostResponseHelper evictee1_response(
resolver_->CreateRequest(HostPortPair("evictee1", 80), NetLogWithSource(),
- base::nullopt),
+ base::nullopt, request_context_.get()),
std::move(custom_callback));
- ResolveHostResponseHelper evictee2_response(resolver_->CreateRequest(
- HostPortPair("evictee2", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper evictee2_response(
+ resolver_->CreateRequest(HostPortPair("evictee2", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
// Now one running request ("initial") and two queued requests ("evictee1" and
// "evictee2"). Any further requests will cause evictions.
- ResolveHostResponseHelper evictor_response(resolver_->CreateRequest(
- HostPortPair("evictor", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper evictor_response(
+ resolver_->CreateRequest(HostPortPair("evictor", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(evictee1_response.result_error(),
IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
@@ -1075,21 +1163,24 @@
[&](CompletionOnceCallback completion_callback, int error) {
new_response = std::make_unique<ResolveHostResponseHelper>(
resolver_->CreateRequest(HostPortPair("new", 70),
- NetLogWithSource(), base::nullopt));
+ NetLogWithSource(), base::nullopt,
+ request_context_.get()));
std::move(completion_callback).Run(error);
});
- ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
- HostPortPair("initial", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper initial_response(
+ resolver_->CreateRequest(HostPortPair("initial", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ResolveHostResponseHelper evictee_response(
resolver_->CreateRequest(HostPortPair("evictee", 80), NetLogWithSource(),
- base::nullopt),
+ base::nullopt, request_context_.get()),
std::move(custom_callback));
// Now one running request ("initial") and one queued requests ("evictee").
// Any further requests will cause evictions.
- ResolveHostResponseHelper evictor_response(resolver_->CreateRequest(
- HostPortPair("evictor", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper evictor_response(
+ resolver_->CreateRequest(HostPortPair("evictor", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(evictee_response.result_error(),
IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
@@ -1112,23 +1203,27 @@
[&](CompletionOnceCallback completion_callback, int error) {
new_response = std::make_unique<ResolveHostResponseHelper>(
resolver_->CreateRequest(HostPortPair("evictor", 70),
- NetLogWithSource(), base::nullopt));
+ NetLogWithSource(), base::nullopt,
+ request_context_.get()));
std::move(completion_callback).Run(error);
});
- ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
- HostPortPair("initial", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper initial_response(
+ resolver_->CreateRequest(HostPortPair("initial", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ResolveHostResponseHelper evictee_response(
resolver_->CreateRequest(HostPortPair("evictee", 80), NetLogWithSource(),
- base::nullopt),
+ base::nullopt, request_context_.get()),
std::move(custom_callback));
ResolveHostResponseHelper additional_response(resolver_->CreateRequest(
- HostPortPair("additional", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("additional", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
// Now one running request ("initial") and two queued requests ("evictee" and
// "additional"). Any further requests will cause evictions.
- ResolveHostResponseHelper evictor_response(resolver_->CreateRequest(
- HostPortPair("evictor", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper evictor_response(
+ resolver_->CreateRequest(HostPortPair("evictor", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(evictee_response.result_error(),
IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
@@ -1146,13 +1241,15 @@
TEST_F(HostResolverManagerTest, BypassCache) {
proc_->SignalMultiple(2u);
- ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
- HostPortPair("a", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper initial_response(
+ resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(initial_response.result_error(), IsOk());
EXPECT_EQ(1u, proc_->GetCaptureList().size());
- ResolveHostResponseHelper cached_response(resolver_->CreateRequest(
- HostPortPair("a", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper cached_response(
+ resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(cached_response.result_error(), IsOk());
// Expect no increase to calls to |proc_| because result was cached.
EXPECT_EQ(1u, proc_->GetCaptureList().size());
@@ -1160,8 +1257,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.cache_usage =
HostResolver::ResolveHostParameters::CacheUsage::DISALLOWED;
- ResolveHostResponseHelper cache_bypassed_response(resolver_->CreateRequest(
- HostPortPair("a", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper cache_bypassed_response(
+ resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(cache_bypassed_response.result_error(), IsOk());
// Expect call to |proc_| because cache was bypassed.
EXPECT_EQ(2u, proc_->GetCaptureList().size());
@@ -1172,20 +1270,23 @@
TEST_F(HostResolverManagerTest, FlushCacheOnIPAddressChange) {
proc_->SignalMultiple(2u); // One before the flush, one after.
- ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
- HostPortPair("host1", 70), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper initial_response(
+ resolver_->CreateRequest(HostPortPair("host1", 70), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(initial_response.result_error(), IsOk());
EXPECT_EQ(1u, proc_->GetCaptureList().size());
- ResolveHostResponseHelper cached_response(resolver_->CreateRequest(
- HostPortPair("host1", 75), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper cached_response(
+ resolver_->CreateRequest(HostPortPair("host1", 75), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
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));
+ ResolveHostResponseHelper unflushed_response(
+ resolver_->CreateRequest(HostPortPair("host1", 75), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(unflushed_response.result_error(), IsOk());
EXPECT_EQ(1u, proc_->GetCaptureList().size()); // No expected increase.
@@ -1195,16 +1296,18 @@
// 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));
+ ResolveHostResponseHelper flushed_response(
+ resolver_->CreateRequest(HostPortPair("host1", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
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(HostResolverManagerTest, AbortOnIPAddressChanged) {
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host1", 70), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host1", 70), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ASSERT_FALSE(response.complete());
ASSERT_TRUE(proc_->WaitFor(1u));
@@ -1221,8 +1324,9 @@
// Test that initial DNS config read signals do not abort pending requests.
TEST_F(HostResolverManagerTest, DontAbortOnInitialDNSConfigRead) {
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host1", 70), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host1", 70), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ASSERT_FALSE(response.complete());
ASSERT_TRUE(proc_->WaitFor(1u));
@@ -1242,15 +1346,15 @@
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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("a", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("b", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("c", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
for (auto& response : responses) {
ASSERT_FALSE(response->complete());
@@ -1284,7 +1388,7 @@
CompletionOnceCallback completion_callback, int error) {
*next_response = std::make_unique<ResolveHostResponseHelper>(
resolver_->CreateRequest(next_host, NetLogWithSource(),
- base::nullopt));
+ base::nullopt, request_context_.get()));
std::move(completion_callback).Run(error);
});
@@ -1292,19 +1396,19 @@
ResolveHostResponseHelper response0(
resolver_->CreateRequest(HostPortPair("bbb", 80), NetLogWithSource(),
- base::nullopt),
+ base::nullopt, request_context_.get()),
base::BindOnce(custom_callback_template, HostPortPair("zzz", 80),
&next_responses[0]));
ResolveHostResponseHelper response1(
resolver_->CreateRequest(HostPortPair("eee", 80), NetLogWithSource(),
- base::nullopt),
+ base::nullopt, request_context_.get()),
base::BindOnce(custom_callback_template, HostPortPair("aaa", 80),
&next_responses[1]));
ResolveHostResponseHelper response2(
resolver_->CreateRequest(HostPortPair("ccc", 80), NetLogWithSource(),
- base::nullopt),
+ base::nullopt, request_context_.get()),
base::BindOnce(custom_callback_template, HostPortPair("eee", 80),
&next_responses[2]));
@@ -1352,30 +1456,30 @@
// 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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req0", 80), NetLogWithSource(),
+ low_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req1", 80), NetLogWithSource(),
+ medium_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req2", 80), NetLogWithSource(),
+ medium_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req3", 80), NetLogWithSource(),
+ low_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req4", 80), NetLogWithSource(),
+ highest_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req5", 80), NetLogWithSource(),
+ low_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req6", 80), NetLogWithSource(),
+ low_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req5", 80), NetLogWithSource(),
+ highest_priority, request_context_.get())));
for (const auto& response : responses) {
ASSERT_FALSE(response->complete());
@@ -1417,15 +1521,15 @@
medium_priority.initial_priority = MEDIUM;
std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("req0", 80), NetLogWithSource(), medium_priority)));
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("req1", 80), NetLogWithSource(), low_priority)));
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("req2", 80), NetLogWithSource(), lowest_priority)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req0", 80), NetLogWithSource(),
+ medium_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req1", 80), NetLogWithSource(),
+ low_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req2", 80), NetLogWithSource(),
+ lowest_priority, request_context_.get())));
// req0 starts immediately; without ChangePriority, req1 and then req2 should
// run.
@@ -1466,27 +1570,27 @@
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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req0", 80), NetLogWithSource(),
+ lowest_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req1", 80), NetLogWithSource(),
+ highest_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req2", 80), NetLogWithSource(),
+ medium_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req3", 80), NetLogWithSource(),
+ low_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req4", 80), NetLogWithSource(),
+ highest_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req5", 80), NetLogWithSource(),
+ lowest_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req6", 80), NetLogWithSource(),
+ medium_priority, request_context_.get())));
// Cancel some requests
responses[1]->CancelRequest();
@@ -1542,46 +1646,46 @@
// 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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req0", 80), NetLogWithSource(),
+ lowest_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req1", 80), NetLogWithSource(),
+ highest_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req2", 80), NetLogWithSource(),
+ medium_priority, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req3", 80), NetLogWithSource(),
+ medium_priority, request_context_.get())));
// 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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req4", 80), NetLogWithSource(),
+ low_priority, request_context_.get())));
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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req5", 80), NetLogWithSource(),
+ medium_priority, request_context_.get())));
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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req6", 80), NetLogWithSource(),
+ highest_priority, request_context_.get())));
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)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("req7", 80), NetLogWithSource(),
+ medium_priority, request_context_.get())));
EXPECT_THAT(responses[5]->result_error(),
IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
EXPECT_FALSE(responses[5]->request()->GetAddressResults());
@@ -1625,11 +1729,13 @@
// 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 run_response(
+ resolver_->CreateRequest(HostPortPair("run", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
- ResolveHostResponseHelper evict_response(resolver_->CreateRequest(
- HostPortPair("req1", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper evict_response(
+ resolver_->CreateRequest(HostPortPair("req1", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(evict_response.result_error(),
IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
EXPECT_FALSE(evict_response.request()->GetAddressResults());
@@ -1650,34 +1756,40 @@
v6_parameters.dns_query_type = DnsQueryType::AAAA;
ResolveHostResponseHelper v4_v4_request(resolver_->CreateRequest(
- HostPortPair("127.0.0.1", 80), NetLogWithSource(), v4_parameters));
+ HostPortPair("127.0.0.1", 80), NetLogWithSource(), v4_parameters,
+ request_context_.get()));
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));
+ HostPortPair("127.0.0.1", 80), NetLogWithSource(), v6_parameters,
+ request_context_.get()));
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));
+ HostPortPair("127.0.0.1", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
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));
+ ResolveHostResponseHelper v6_v4_request(
+ resolver_->CreateRequest(HostPortPair("::1", 80), NetLogWithSource(),
+ v4_parameters, request_context_.get()));
EXPECT_THAT(v6_v4_request.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
- ResolveHostResponseHelper v6_v6_request(resolver_->CreateRequest(
- HostPortPair("::1", 80), NetLogWithSource(), v6_parameters));
+ ResolveHostResponseHelper v6_v6_request(
+ resolver_->CreateRequest(HostPortPair("::1", 80), NetLogWithSource(),
+ v6_parameters, request_context_.get()));
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));
+ ResolveHostResponseHelper v6_unsp_request(
+ resolver_->CreateRequest(HostPortPair("::1", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(v6_unsp_request.result_error(), IsOk());
EXPECT_THAT(
v6_unsp_request.request()->GetAddressResults().value().endpoints(),
@@ -1692,9 +1804,9 @@
source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
// First NONE query expected to complete synchronously with a cache miss.
- ResolveHostResponseHelper cache_miss_request(
- resolver_->CreateRequest(HostPortPair("just.testing", 80),
- NetLogWithSource(), source_none_parameters));
+ ResolveHostResponseHelper cache_miss_request(resolver_->CreateRequest(
+ HostPortPair("just.testing", 80), NetLogWithSource(),
+ source_none_parameters, request_context_.get()));
EXPECT_TRUE(cache_miss_request.complete());
EXPECT_THAT(cache_miss_request.result_error(), IsError(ERR_DNS_CACHE_MISS));
EXPECT_FALSE(cache_miss_request.request()->GetAddressResults());
@@ -1702,14 +1814,15 @@
// Normal query to populate the cache.
ResolveHostResponseHelper normal_request(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(normal_request.result_error(), IsOk());
EXPECT_FALSE(normal_request.request()->GetStaleInfo());
// Second NONE query expected to complete synchronously with cache hit.
- ResolveHostResponseHelper cache_hit_request(
- resolver_->CreateRequest(HostPortPair("just.testing", 80),
- NetLogWithSource(), source_none_parameters));
+ ResolveHostResponseHelper cache_hit_request(resolver_->CreateRequest(
+ HostPortPair("just.testing", 80), NetLogWithSource(),
+ source_none_parameters, request_context_.get()));
EXPECT_TRUE(cache_hit_request.complete());
EXPECT_THAT(cache_hit_request.result_error(), IsOk());
EXPECT_THAT(
@@ -1726,9 +1839,9 @@
source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
// First NONE query expected to complete synchronously with a cache miss.
- ResolveHostResponseHelper cache_miss_request(
- resolver_->CreateRequest(HostPortPair("just.testing", 80),
- NetLogWithSource(), source_none_parameters));
+ ResolveHostResponseHelper cache_miss_request(resolver_->CreateRequest(
+ HostPortPair("just.testing", 80), NetLogWithSource(),
+ source_none_parameters, request_context_.get()));
EXPECT_TRUE(cache_miss_request.complete());
EXPECT_THAT(cache_miss_request.result_error(), IsError(ERR_DNS_CACHE_MISS));
EXPECT_FALSE(cache_miss_request.request()->GetAddressResults());
@@ -1736,16 +1849,17 @@
// Normal query to populate the cache.
ResolveHostResponseHelper normal_request(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(normal_request.result_error(), IsOk());
EXPECT_FALSE(normal_request.request()->GetStaleInfo());
MakeCacheStale();
// Second NONE query still expected to complete synchronously with cache miss.
- ResolveHostResponseHelper stale_request(
- resolver_->CreateRequest(HostPortPair("just.testing", 80),
- NetLogWithSource(), source_none_parameters));
+ ResolveHostResponseHelper stale_request(resolver_->CreateRequest(
+ HostPortPair("just.testing", 80), NetLogWithSource(),
+ source_none_parameters, request_context_.get()));
EXPECT_TRUE(stale_request.complete());
EXPECT_THAT(stale_request.result_error(), IsError(ERR_DNS_CACHE_MISS));
EXPECT_FALSE(stale_request.request()->GetAddressResults());
@@ -1756,8 +1870,9 @@
HostResolver::ResolveHostParameters source_none_parameters;
source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("1.2.3.4", 56), NetLogWithSource(), source_none_parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("1.2.3.4", 56), NetLogWithSource(),
+ source_none_parameters, request_context_.get()));
// Expected to resolve synchronously.
EXPECT_TRUE(response.complete());
@@ -1773,9 +1888,9 @@
HostResolver::ResolveHostParameters source_none_parameters;
source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
- ResolveHostResponseHelper response(
- resolver_->CreateRequest(HostPortPair("foo,bar.com", 57),
- NetLogWithSource(), source_none_parameters));
+ ResolveHostResponseHelper response(resolver_->CreateRequest(
+ HostPortPair("foo,bar.com", 57), NetLogWithSource(),
+ source_none_parameters, request_context_.get()));
// Expected to fail synchronously.
EXPECT_TRUE(response.complete());
@@ -1788,9 +1903,9 @@
HostResolver::ResolveHostParameters source_none_parameters;
source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
- ResolveHostResponseHelper response(
- resolver_->CreateRequest(HostPortPair("foo,bar.localhost", 58),
- NetLogWithSource(), source_none_parameters));
+ ResolveHostResponseHelper response(resolver_->CreateRequest(
+ HostPortPair("foo,bar.localhost", 58), NetLogWithSource(),
+ source_none_parameters, request_context_.get()));
// Expected to fail synchronously.
EXPECT_TRUE(response.complete());
@@ -1809,9 +1924,9 @@
HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
// First query expected to complete synchronously as a cache miss.
- ResolveHostResponseHelper cache_miss_request(
- resolver_->CreateRequest(HostPortPair("just.testing", 80),
- NetLogWithSource(), stale_allowed_parameters));
+ ResolveHostResponseHelper cache_miss_request(resolver_->CreateRequest(
+ HostPortPair("just.testing", 80), NetLogWithSource(),
+ stale_allowed_parameters, request_context_.get()));
EXPECT_TRUE(cache_miss_request.complete());
EXPECT_THAT(cache_miss_request.result_error(), IsError(ERR_DNS_CACHE_MISS));
EXPECT_FALSE(cache_miss_request.request()->GetAddressResults());
@@ -1819,16 +1934,17 @@
// Normal query to populate cache
ResolveHostResponseHelper normal_request(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(normal_request.result_error(), IsOk());
EXPECT_FALSE(normal_request.request()->GetStaleInfo());
MakeCacheStale();
// Second NONE query expected to get a stale cache hit.
- ResolveHostResponseHelper stale_request(
- resolver_->CreateRequest(HostPortPair("just.testing", 84),
- NetLogWithSource(), stale_allowed_parameters));
+ ResolveHostResponseHelper stale_request(resolver_->CreateRequest(
+ HostPortPair("just.testing", 84), NetLogWithSource(),
+ stale_allowed_parameters, request_context_.get()));
EXPECT_TRUE(stale_request.complete());
EXPECT_THAT(stale_request.result_error(), IsOk());
EXPECT_THAT(stale_request.request()->GetAddressResults().value().endpoints(),
@@ -1846,9 +1962,9 @@
// Normal non-local resolves should still work normally with the STALE_ALLOWED
// parameter, and there should be no stale info.
- ResolveHostResponseHelper response(
- resolver_->CreateRequest(HostPortPair("just.testing", 85),
- NetLogWithSource(), stale_allowed_parameters));
+ ResolveHostResponseHelper response(resolver_->CreateRequest(
+ HostPortPair("just.testing", 85), NetLogWithSource(),
+ stale_allowed_parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
testing::ElementsAre(CreateExpected("192.168.2.42", 85)));
@@ -1860,9 +1976,9 @@
stale_allowed_parameters.cache_usage =
HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
- ResolveHostResponseHelper response(
- resolver_->CreateRequest(HostPortPair("1.2.3.4", 57), NetLogWithSource(),
- stale_allowed_parameters));
+ ResolveHostResponseHelper response(resolver_->CreateRequest(
+ HostPortPair("1.2.3.4", 57), NetLogWithSource(), stale_allowed_parameters,
+ request_context_.get()));
// Expected to resolve synchronously without stale info.
EXPECT_TRUE(response.complete());
@@ -1907,8 +2023,9 @@
base::ThreadTaskRunnerHandle::OverrideForTesting(test_task_runner);
// Resolve "host1".
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host1", 70), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host1", 70), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_FALSE(response.complete());
resolver_proc->WaitForNAttemptsToBeBlocked(1);
@@ -1950,8 +2067,9 @@
proc_->AddRuleForAllFamilies("not_reserved3", "10.0.53.53");
proc_->SignalMultiple(6u);
- ResolveHostResponseHelper single_response(resolver_->CreateRequest(
- HostPortPair("single", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper single_response(
+ resolver_->CreateRequest(HostPortPair("single", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(single_response.result_error(),
IsError(ERR_ICANN_NAME_COLLISION));
EXPECT_FALSE(single_response.request()->GetAddressResults());
@@ -1965,34 +2083,40 @@
HostResolverSource::ANY));
EXPECT_FALSE(cache_result);
- ResolveHostResponseHelper multiple_response(resolver_->CreateRequest(
- HostPortPair("multiple", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper multiple_response(
+ resolver_->CreateRequest(HostPortPair("multiple", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(multiple_response.result_error(),
IsError(ERR_ICANN_NAME_COLLISION));
// Resolving an IP literal of 127.0.53.53 however is allowed.
ResolveHostResponseHelper literal_response(resolver_->CreateRequest(
- HostPortPair("127.0.53.53", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("127.0.53.53", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(literal_response.result_error(), IsOk());
// Moreover the address should not be recognized when embedded in an IPv6
// address.
ResolveHostResponseHelper ipv6_response(resolver_->CreateRequest(
- HostPortPair("127.0.53.53", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("127.0.53.53", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(ipv6_response.result_error(), IsOk());
// Try some other IPs which are similar, but NOT an exact match on
// 127.0.53.53.
ResolveHostResponseHelper similar_response1(resolver_->CreateRequest(
- HostPortPair("not_reserved1", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("not_reserved1", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(similar_response1.result_error(), IsOk());
ResolveHostResponseHelper similar_response2(resolver_->CreateRequest(
- HostPortPair("not_reserved2", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("not_reserved2", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(similar_response2.result_error(), IsOk());
ResolveHostResponseHelper similar_response3(resolver_->CreateRequest(
- HostPortPair("not_reserved3", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("not_reserved3", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(similar_response3.result_error(), IsOk());
}
@@ -2037,9 +2161,11 @@
HostResolver::ResolveHostParameters parameters;
parameters.include_canonical_name = true;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), parameters));
+ HostPortPair("just.testing", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
ResolveHostResponseHelper response_no_flag(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
@@ -2058,9 +2184,11 @@
HostResolver::ResolveHostParameters parameters;
parameters.loopback_only = true;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("otherlocal", 80), NetLogWithSource(), parameters));
+ HostPortPair("otherlocal", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
ResolveHostResponseHelper response_no_flag(resolver_->CreateRequest(
- HostPortPair("otherlocal", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("otherlocal", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
@@ -2077,7 +2205,8 @@
parameters.is_speculative = true;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), parameters));
+ HostPortPair("just.testing", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_FALSE(response.request()->GetAddressResults());
@@ -2088,7 +2217,8 @@
// Reresolve without the |is_speculative| flag should immediately return from
// cache.
ResolveHostResponseHelper response2(resolver_->CreateRequest(
- HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("just.testing", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response2.result_error(), IsOk());
EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
@@ -2360,7 +2490,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
socket_factory_ptr->SimulateReceive(kMdnsResponseA, sizeof(kMdnsResponseA));
socket_factory_ptr->SimulateReceive(kMdnsResponseAAAA,
@@ -2388,7 +2519,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
socket_factory_ptr->SimulateReceive(kMdnsResponseAAAA,
sizeof(kMdnsResponseAAAA));
@@ -2411,7 +2543,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
socket_factory_ptr->SimulateReceive(kMdnsResponseTxt,
sizeof(kMdnsResponseTxt));
@@ -2435,7 +2568,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 83), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 83), NetLogWithSource(), parameters,
+ request_context_.get()));
socket_factory_ptr->SimulateReceive(kMdnsResponsePtr,
sizeof(kMdnsResponsePtr));
@@ -2460,7 +2594,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 83), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 83), NetLogWithSource(), parameters,
+ request_context_.get()));
socket_factory_ptr->SimulateReceive(kMdnsResponseSrv,
sizeof(kMdnsResponseSrv));
@@ -2486,7 +2621,7 @@
ResolveHostResponseHelper response(resolver_->CreateRequest(
HostPortPair("foo bar(A1B2)._ipps._tcp.local", 83), NetLogWithSource(),
- parameters));
+ parameters, request_context_.get()));
socket_factory_ptr->SimulateReceive(kMdnsResponseSrvUnrestricted,
sizeof(kMdnsResponseSrvUnrestricted));
@@ -2511,7 +2646,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 83), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 83), NetLogWithSource(), parameters,
+ request_context_.get()));
socket_factory_ptr->SimulateReceive(
kMdnsResponseSrvUnrestrictedResult,
@@ -2539,7 +2675,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
socket_factory_ptr->SimulateReceive(kMdnsResponseNsec,
sizeof(kMdnsResponseNsec));
@@ -2570,7 +2707,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
ASSERT_TRUE(test_task_runner->HasPendingTask());
test_task_runner->FastForwardBy(MDnsTransaction::kTransactionTimeout +
@@ -2607,7 +2745,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
// Not the requested type. Should be ignored.
socket_factory_ptr->SimulateReceive(kMdnsResponseTxt,
@@ -2649,7 +2788,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
ASSERT_TRUE(test_task_runner->HasPendingTask());
@@ -2675,7 +2815,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
response.CancelRequest();
@@ -2711,7 +2852,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_FAILED));
EXPECT_FALSE(response.request()->GetAddressResults());
@@ -2728,7 +2870,8 @@
parameters.source = HostResolverSource::MULTICAST_DNS;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_FAILED));
EXPECT_FALSE(response.request()->GetAddressResults());
@@ -3233,21 +3376,24 @@
proc_->AddRuleForAllFamilies("localhost.", "192.168.1.42");
ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("foo.localhost", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("foo.localhost", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response0.result_error(), IsOk());
EXPECT_THAT(response0.request()->GetAddressResults().value().endpoints(),
testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
CreateExpected("::1", 80)));
ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response1.result_error(), IsOk());
EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
CreateExpected("::1", 80)));
ResolveHostResponseHelper response2(resolver_->CreateRequest(
- HostPortPair("localhost.", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("localhost.", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response2.result_error(), IsOk());
EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
@@ -3268,14 +3414,16 @@
ChangeDnsConfig(config);
ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response0.result_error(), IsOk());
EXPECT_THAT(response0.request()->GetAddressResults().value().endpoints(),
testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
CreateExpected("::1", 80)));
ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("foo.localhost", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("foo.localhost", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response1.result_error(), IsOk());
EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
@@ -3288,8 +3436,9 @@
// All other hostnames will fail in proc_.
// Initially there is no config, so client should not be invoked.
- ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
- HostPortPair("ok_fail", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper initial_response(
+ resolver_->CreateRequest(HostPortPair("ok_fail", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_FALSE(initial_response.complete());
proc_->SignalMultiple(1u);
@@ -3298,12 +3447,15 @@
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("ok_fail", 80), NetLogWithSource(), base::nullopt));
- ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("nx_fail", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response0(
+ resolver_->CreateRequest(HostPortPair("ok_fail", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
+ ResolveHostResponseHelper response1(
+ resolver_->CreateRequest(HostPortPair("nx_fail", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ResolveHostResponseHelper response2(resolver_->CreateRequest(
- HostPortPair("nx_succeed", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("nx_succeed", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
proc_->SignalMultiple(4u);
@@ -3331,10 +3483,12 @@
// Set empty DnsConfig.
ChangeDnsConfig(DnsConfig());
// Initially there is no config, so client should not be invoked.
- ResolveHostResponseHelper initial_response0(resolver_->CreateRequest(
- HostPortPair("ok_fail", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper initial_response0(
+ resolver_->CreateRequest(HostPortPair("ok_fail", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ResolveHostResponseHelper initial_response1(resolver_->CreateRequest(
- HostPortPair("nx_succeed", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("nx_succeed", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
proc_->SignalMultiple(2u);
EXPECT_THAT(initial_response0.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
@@ -3345,10 +3499,12 @@
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper abort_response0(resolver_->CreateRequest(
- HostPortPair("ok_abort", 80), NetLogWithSource(), base::nullopt));
- ResolveHostResponseHelper abort_response1(resolver_->CreateRequest(
- HostPortPair("nx_abort", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper abort_response0(
+ resolver_->CreateRequest(HostPortPair("ok_abort", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
+ ResolveHostResponseHelper abort_response1(
+ resolver_->CreateRequest(HostPortPair("nx_abort", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
// Simulate the case when the preference or policy has disabled the DNS
// client causing AbortDnsTasks.
@@ -3356,10 +3512,12 @@
// First request is resolved by MockDnsClient, others should fail due to
// disabled fallback to ProcTask.
- ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("ok_fail", 80), NetLogWithSource(), base::nullopt));
- ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("nx_fail", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response0(
+ resolver_->CreateRequest(HostPortPair("ok_fail", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
+ ResolveHostResponseHelper response1(
+ resolver_->CreateRequest(HostPortPair("nx_fail", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
proc_->SignalMultiple(6u);
// Aborted due to Network Change.
@@ -3377,8 +3535,9 @@
// Test behavior of OnDnsTaskFailure when Job is aborted.
TEST_F(HostResolverManagerDnsTest, OnDnsTaskFailureAbortedJob) {
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("nx_abort", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("nx_abort", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
// Abort all jobs here.
CreateResolver();
proc_->SignalMultiple(1u);
@@ -3390,8 +3549,9 @@
// Repeat test with Fallback to ProcTask disabled
set_allow_fallback_to_proctask(false);
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper no_fallback_response(resolver_->CreateRequest(
- HostPortPair("nx_abort", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper no_fallback_response(
+ resolver_->CreateRequest(HostPortPair("nx_abort", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
// Abort all jobs here.
CreateResolver();
proc_->SignalMultiple(2u);
@@ -3411,10 +3571,12 @@
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("nx_fail", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response0(
+ resolver_->CreateRequest(HostPortPair("nx_fail", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("nx_succeed", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("nx_succeed", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
proc_->SignalMultiple(2u);
EXPECT_THAT(response0.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
@@ -3435,10 +3597,12 @@
HostResolver::ResolveHostParameters parameters;
parameters.source = HostResolverSource::DNS;
- ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("nx_fail", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response0(
+ resolver_->CreateRequest(HostPortPair("nx_fail", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("nx_succeed", 80), NetLogWithSource(), parameters));
+ HostPortPair("nx_succeed", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
// Nothing should reach |proc_| on success, but let failures through to fail
// instead of hanging.
proc_->SignalMultiple(2u);
@@ -3457,10 +3621,12 @@
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("ok_fail", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response0(
+ resolver_->CreateRequest(HostPortPair("ok_fail", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("nx_succeed", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("nx_succeed", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
proc_->SignalMultiple(2u);
// Simulate the case when the preference or policy has disabled the DNS client
@@ -3486,10 +3652,12 @@
HostResolver::ResolveHostParameters parameters;
parameters.source = HostResolverSource::DNS;
- ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("ok_fail", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response0(
+ resolver_->CreateRequest(HostPortPair("ok_fail", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("nx_succeed", 80), NetLogWithSource(), parameters));
+ HostPortPair("nx_succeed", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
// Nothing should reach |proc_| on success, but let failures through to fail
// instead of hanging.
proc_->SignalMultiple(2u);
@@ -3510,18 +3678,18 @@
// All other hostnames will fail in proc_.
std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt)));
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("4ok", 80), NetLogWithSource(), base::nullopt)));
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("6ok", 80), NetLogWithSource(), base::nullopt)));
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("4nx", 80), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("4ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("6ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("4nx", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
proc_->SignalMultiple(4u);
@@ -3546,7 +3714,8 @@
// When the resolver returns an A record with 127.0.53.53 it should be
// mapped to a special error.
ResolveHostResponseHelper response_ipv4(resolver_->CreateRequest(
- HostPortPair("4collision", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("4collision", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response_ipv4.result_error(), IsError(ERR_ICANN_NAME_COLLISION));
EXPECT_FALSE(response_ipv4.request()->GetAddressResults());
@@ -3554,7 +3723,8 @@
// work just like any other IP. (Despite having the same suffix, it is not
// considered special)
ResolveHostResponseHelper response_ipv6(resolver_->CreateRequest(
- HostPortPair("6collision", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("6collision", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response_ipv6.result_error(), IsOk());
EXPECT_THAT(response_ipv6.request()->GetAddressResults().value().endpoints(),
testing::ElementsAre(CreateExpected("::127.0.53.53", 80)));
@@ -3569,8 +3739,9 @@
std::string()); // Default to failures.
proc_->SignalMultiple(1u); // For the first request which misses.
- ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
- HostPortPair("nx_ipv4", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper initial_response(
+ resolver_->CreateRequest(HostPortPair("nx_ipv4", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(initial_response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
IPAddress local_ipv4 = IPAddress::IPv4Localhost();
@@ -3586,20 +3757,23 @@
config.hosts = hosts;
ChangeDnsConfig(config);
- ResolveHostResponseHelper response_ipv4(resolver_->CreateRequest(
- HostPortPair("nx_ipv4", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response_ipv4(
+ resolver_->CreateRequest(HostPortPair("nx_ipv4", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(response_ipv4.result_error(), IsOk());
EXPECT_THAT(response_ipv4.request()->GetAddressResults().value().endpoints(),
testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
- ResolveHostResponseHelper response_ipv6(resolver_->CreateRequest(
- HostPortPair("nx_ipv6", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response_ipv6(
+ resolver_->CreateRequest(HostPortPair("nx_ipv6", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(response_ipv6.result_error(), IsOk());
EXPECT_THAT(response_ipv6.request()->GetAddressResults().value().endpoints(),
testing::ElementsAre(CreateExpected("::1", 80)));
- ResolveHostResponseHelper response_both(resolver_->CreateRequest(
- HostPortPair("nx_both", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response_both(
+ resolver_->CreateRequest(HostPortPair("nx_both", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(response_both.result_error(), IsOk());
EXPECT_THAT(response_both.request()->GetAddressResults().value().endpoints(),
testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
@@ -3609,8 +3783,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::A;
- ResolveHostResponseHelper response_specified_ipv4(resolver_->CreateRequest(
- HostPortPair("nx_ipv4", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response_specified_ipv4(
+ resolver_->CreateRequest(HostPortPair("nx_ipv4", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response_specified_ipv4.result_error(), IsOk());
EXPECT_THAT(response_specified_ipv4.request()
->GetAddressResults()
@@ -3619,8 +3794,9 @@
testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
parameters.dns_query_type = DnsQueryType::AAAA;
- ResolveHostResponseHelper response_specified_ipv6(resolver_->CreateRequest(
- HostPortPair("nx_ipv6", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response_specified_ipv6(
+ resolver_->CreateRequest(HostPortPair("nx_ipv6", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response_specified_ipv6.result_error(), IsOk());
EXPECT_THAT(response_specified_ipv6.request()
->GetAddressResults()
@@ -3629,8 +3805,9 @@
testing::ElementsAre(CreateExpected("::1", 80)));
// Request with upper case.
- ResolveHostResponseHelper response_upper(resolver_->CreateRequest(
- HostPortPair("nx_IPV4", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response_upper(
+ resolver_->CreateRequest(HostPortPair("nx_IPV4", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(response_upper.result_error(), IsOk());
EXPECT_THAT(response_upper.request()->GetAddressResults().value().endpoints(),
testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
@@ -3648,10 +3825,12 @@
std::string()); // Default to failures.
proc_->SignalMultiple(1u); // For the first request which fails.
- ResolveHostResponseHelper failure_response(resolver_->CreateRequest(
- HostPortPair("nx_ipv4", 80), NetLogWithSource(), base::nullopt));
- ResolveHostResponseHelper queued_response(resolver_->CreateRequest(
- HostPortPair("nx_ipv6", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper failure_response(
+ resolver_->CreateRequest(HostPortPair("nx_ipv4", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
+ ResolveHostResponseHelper queued_response(
+ resolver_->CreateRequest(HostPortPair("nx_ipv6", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
DnsHosts hosts;
hosts[DnsHostsKey("nx_ipv4", ADDRESS_FAMILY_IPV4)] =
@@ -3690,21 +3869,22 @@
std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("ok.local", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
responses.emplace_back(
std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("ok.local", 80), NetLogWithSource(), base::nullopt)));
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("ok.local.", 80), NetLogWithSource(), base::nullopt)));
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("oklocal", 80), NetLogWithSource(), base::nullopt)));
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("oklocal.", 80), NetLogWithSource(), base::nullopt)));
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt)));
+ HostPortPair("ok.local.", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("oklocal", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("oklocal.", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
proc_->SignalMultiple(5u);
@@ -3738,7 +3918,8 @@
dns_parameters.dns_query_type = DnsQueryType::TXT;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("myhello.local", 80), NetLogWithSource(), dns_parameters));
+ HostPortPair("myhello.local", 80), NetLogWithSource(), dns_parameters,
+ request_context_.get()));
socket_factory_ptr->SimulateReceive(kMdnsResponseTxt,
sizeof(kMdnsResponseTxt));
@@ -3760,12 +3941,15 @@
HostResolver::ResolveHostParameters dns_parameters;
dns_parameters.source = HostResolverSource::DNS;
- ResolveHostResponseHelper dns_response(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), dns_parameters));
- ResolveHostResponseHelper dns_local_response(resolver_->CreateRequest(
- HostPortPair("ok.local", 80), NetLogWithSource(), dns_parameters));
- ResolveHostResponseHelper normal_local_response(resolver_->CreateRequest(
- HostPortPair("ok.local", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper dns_response(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ dns_parameters, request_context_.get()));
+ ResolveHostResponseHelper dns_local_response(
+ resolver_->CreateRequest(HostPortPair("ok.local", 80), NetLogWithSource(),
+ dns_parameters, request_context_.get()));
+ ResolveHostResponseHelper normal_local_response(
+ resolver_->CreateRequest(HostPortPair("ok.local", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
proc_->SignalMultiple(3u);
@@ -3780,13 +3964,15 @@
ChangeDnsConfig(CreateValidDnsConfig());
proc_->AddRuleForAllFamilies(std::string(), std::string());
- ResolveHostResponseHelper dns_response(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper dns_response(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
HostResolver::ResolveHostParameters parameters;
parameters.source = HostResolverSource::SYSTEM;
- ResolveHostResponseHelper system_response(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper system_response(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
proc_->SignalMultiple(2u);
@@ -3801,8 +3987,9 @@
std::string()); // Default to failures.
// Check that DnsTask works.
- ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
- HostPortPair("ok_1", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper initial_response(
+ resolver_->CreateRequest(HostPortPair("ok_1", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(initial_response.result_error(), IsOk());
std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
@@ -3811,9 +3998,9 @@
std::string hostname = base::StringPrintf("nx_%u", i);
// Ensure fallback to ProcTask succeeds.
proc_->AddRuleForAllFamilies(hostname, "192.168.1.101");
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair(hostname, 80), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair(hostname, 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
}
proc_->SignalMultiple(responses.size());
@@ -3824,20 +4011,23 @@
ASSERT_FALSE(proc_->HasBlockedRequests());
// DnsTask should be disabled by now unless explictly requested via |source|.
- ResolveHostResponseHelper fail_response(resolver_->CreateRequest(
- HostPortPair("ok_2", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper fail_response(
+ resolver_->CreateRequest(HostPortPair("ok_2", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
HostResolver::ResolveHostParameters parameters;
parameters.source = HostResolverSource::DNS;
- ResolveHostResponseHelper dns_response(resolver_->CreateRequest(
- HostPortPair("ok_2", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper dns_response(
+ resolver_->CreateRequest(HostPortPair("ok_2", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
proc_->SignalMultiple(2u);
EXPECT_THAT(fail_response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_THAT(dns_response.result_error(), IsOk());
// Check that it is re-enabled after DNS change.
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper reenabled_response(resolver_->CreateRequest(
- HostPortPair("ok_3", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper reenabled_response(
+ resolver_->CreateRequest(HostPortPair("ok_3", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(reenabled_response.result_error(), IsOk());
}
@@ -3852,9 +4042,9 @@
// Use custom names to require separate Jobs.
std::string hostname = (i % 2) == 0 ? base::StringPrintf("nx_%u", i)
: base::StringPrintf("ok_%u", i);
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair(hostname, 80), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair(hostname, 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
}
proc_->SignalMultiple(40u);
@@ -3866,8 +4056,9 @@
proc_->AddRuleForAllFamilies(std::string(), std::string());
// DnsTask should still be enabled.
- ResolveHostResponseHelper final_response(resolver_->CreateRequest(
- HostPortPair("ok_last", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper final_response(
+ resolver_->CreateRequest(HostPortPair("ok_last", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(final_response.result_error(), IsOk());
}
@@ -3884,7 +4075,8 @@
// Try without DnsClient.
resolver_->SetDnsClient(nullptr);
ResolveHostResponseHelper system_response(resolver_->CreateRequest(
- HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(system_response.result_error(), IsOk());
EXPECT_THAT(
system_response.request()->GetAddressResults().value().endpoints(),
@@ -3894,7 +4086,8 @@
// With DnsClient
UseMockDnsClient(CreateValidDnsConfig(), CreateDefaultDnsRules());
ResolveHostResponseHelper builtin_response(resolver_->CreateRequest(
- HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(builtin_response.result_error(), IsOk());
EXPECT_THAT(
builtin_response.request()->GetAddressResults().value().endpoints(),
@@ -3907,7 +4100,8 @@
config.use_local_ipv6 = false;
ChangeDnsConfig(config);
ResolveHostResponseHelper ipv6_disabled_response(resolver_->CreateRequest(
- HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("localhost", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(ipv6_disabled_response.result_error(), IsOk());
EXPECT_THAT(
ipv6_disabled_response.request()->GetAddressResults().value().endpoints(),
@@ -3924,8 +4118,9 @@
config.use_local_ipv6 = false;
ChangeDnsConfig(config);
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ASSERT_FALSE(response.complete());
ASSERT_EQ(1u, num_running_dispatcher_jobs());
@@ -3941,8 +4136,9 @@
CreateSerialResolver();
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_EQ(1u, num_running_dispatcher_jobs());
response.CancelRequest();
@@ -3956,8 +4152,9 @@
TEST_F(HostResolverManagerDnsTest, CancelWithTwoTransactionsActive) {
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_EQ(2u, num_running_dispatcher_jobs());
response.CancelRequest();
@@ -3979,9 +4176,9 @@
std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
for (int i = 0; i < 12; ++i) {
std::string hostname = base::StringPrintf("ok%i", i);
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair(hostname, 80), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair(hostname, 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
}
EXPECT_EQ(10u, num_running_dispatcher_jobs());
@@ -3996,8 +4193,9 @@
TEST_F(HostResolverManagerDnsTest, DeleteWithCompletedRequests) {
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
@@ -4016,7 +4214,8 @@
ChangeDnsConfig(CreateValidDnsConfig());
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("4slow_4ok", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("4slow_4ok", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
response.request()->Cancel();
dns_client_->CompleteDelayedTransactions();
@@ -4028,8 +4227,9 @@
TEST_F(HostResolverManagerDnsTest, ExplicitCancel_Completed) {
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
@@ -4048,8 +4248,9 @@
TEST_F(HostResolverManagerDnsTest, CancelWithIPv6TransactionActive) {
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("6slow_ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("6slow_ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_EQ(2u, num_running_dispatcher_jobs());
// The IPv4 request should complete, the IPv6 request is still pending.
@@ -4068,8 +4269,9 @@
set_allow_fallback_to_proctask(false);
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("4slow_ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("4slow_ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_EQ(2u, num_running_dispatcher_jobs());
// The IPv6 request should complete, the IPv4 request is still pending.
@@ -4087,18 +4289,21 @@
ChangeDnsConfig(CreateValidDnsConfig());
std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("4slow_ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
responses.emplace_back(
std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("4slow_ok", 80), NetLogWithSource(), base::nullopt)));
+ HostPortPair("4slow_4ok", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get())));
responses.emplace_back(
std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("4slow_4ok", 80), NetLogWithSource(), base::nullopt)));
- responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
- resolver_->CreateRequest(HostPortPair("4slow_4timeout", 80),
- NetLogWithSource(), base::nullopt)));
- responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
- resolver_->CreateRequest(HostPortPair("4slow_6timeout", 80),
- NetLogWithSource(), base::nullopt)));
+ HostPortPair("4slow_4timeout", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get())));
+ responses.emplace_back(
+ std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
+ HostPortPair("4slow_6timeout", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get())));
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(responses[0]->complete());
@@ -4157,24 +4362,29 @@
set_allow_fallback_to_proctask(false);
std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("secure", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
responses.emplace_back(
std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("secure", 80), NetLogWithSource(), base::nullopt)));
- responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
- resolver_->CreateRequest(HostPortPair("4insecure_6slowsecure", 80),
- NetLogWithSource(), base::nullopt)));
- responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
- resolver_->CreateRequest(HostPortPair("4insecure_6slowemptysecure", 80),
- NetLogWithSource(), base::nullopt)));
- responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
- resolver_->CreateRequest(HostPortPair("4insecureempty_6slowsecure", 80),
- NetLogWithSource(), base::nullopt)));
- responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
- resolver_->CreateRequest(HostPortPair("4insecure_6slowfailsecure", 80),
- NetLogWithSource(), base::nullopt)));
- responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
- resolver_->CreateRequest(HostPortPair("4secure_6slowinsecure", 80),
- NetLogWithSource(), base::nullopt)));
+ HostPortPair("4insecure_6slowsecure", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(
+ std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
+ HostPortPair("4insecure_6slowemptysecure", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(
+ std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
+ HostPortPair("4insecureempty_6slowsecure", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(
+ std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
+ HostPortPair("4insecure_6slowfailsecure", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(
+ std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
+ HostPortPair("4secure_6slowinsecure", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(responses[0]->complete());
@@ -4251,8 +4461,9 @@
set_allow_fallback_to_proctask(false);
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_FALSE(response.complete());
EXPECT_EQ(1u, num_running_dispatcher_jobs());
@@ -4273,11 +4484,13 @@
set_allow_fallback_to_proctask(false);
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response0(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_EQ(2u, num_running_dispatcher_jobs());
- ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("4slow_ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response1(
+ resolver_->CreateRequest(HostPortPair("4slow_ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_EQ(3u, num_running_dispatcher_jobs());
// Request 0's transactions should complete, starting Request 1's second
@@ -4309,7 +4522,8 @@
proc_->SignalMultiple(1u);
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("empty_fallback", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("empty_fallback", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
testing::ElementsAre(CreateExpected("192.168.0.1", 80)));
@@ -4323,7 +4537,8 @@
proc_->SignalMultiple(1u);
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("empty_fallback", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("empty_fallback", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
@@ -4347,16 +4562,16 @@
std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
// First active job gets two slots.
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("slow_nx1", 80), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("slow_nx1", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
// Next job gets one slot, and waits on another.
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("slow_nx2", 80), NetLogWithSource(), base::nullopt)));
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("slow_nx2", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
EXPECT_EQ(3u, num_running_dispatcher_jobs());
for (auto& response : responses) {
@@ -4385,8 +4600,9 @@
TEST_F(HostResolverManagerDnsTest, DontAbortOnInitialDNSConfigRead) {
// DnsClient is enabled, but there's no DnsConfig, so the request should start
// using ProcTask.
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host1", 70), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host1", 70), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_FALSE(response.complete());
EXPECT_TRUE(proc_->WaitFor(1u));
@@ -4420,7 +4636,8 @@
proc_->AddRuleForAllFamilies(host, "192.168.0.1");
failure_responses.emplace_back(
std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair(host, 80), NetLogWithSource(), base::nullopt)));
+ HostPortPair(host, 80), NetLogWithSource(), base::nullopt,
+ request_context_.get())));
EXPECT_FALSE(failure_responses[i]->complete());
}
@@ -4428,15 +4645,18 @@
// so should end up using ProcTasks.
proc_->AddRuleForAllFamilies("slow_ok1", "192.168.0.2");
ResolveHostResponseHelper response0(resolver_->CreateRequest(
- HostPortPair("slow_ok1", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("slow_ok1", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_FALSE(response0.complete());
proc_->AddRuleForAllFamilies("slow_ok2", "192.168.0.3");
ResolveHostResponseHelper response1(resolver_->CreateRequest(
- HostPortPair("slow_ok2", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("slow_ok2", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_FALSE(response1.complete());
proc_->AddRuleForAllFamilies("slow_ok3", "192.168.0.4");
ResolveHostResponseHelper response2(resolver_->CreateRequest(
- HostPortPair("slow_ok3", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("slow_ok3", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
EXPECT_FALSE(response2.complete());
// Requests specifying DNS source cannot fallback to ProcTask, so they
@@ -4444,15 +4664,17 @@
HostResolver::ResolveHostParameters parameters;
parameters.source = HostResolverSource::DNS;
ResolveHostResponseHelper response_dns(resolver_->CreateRequest(
- HostPortPair("4slow_ok", 80), NetLogWithSource(), parameters));
+ HostPortPair("4slow_ok", 80), NetLogWithSource(), parameters,
+ request_context_.get()));
EXPECT_FALSE(response_dns.complete());
// Requests specifying SYSTEM source should be unaffected by disabling
// DnsClient.
proc_->AddRuleForAllFamilies("nx_ok", "192.168.0.5");
parameters.source = HostResolverSource::SYSTEM;
- ResolveHostResponseHelper response_system(resolver_->CreateRequest(
- HostPortPair("nx_ok", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response_system(
+ resolver_->CreateRequest(HostPortPair("nx_ok", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_FALSE(response_system.complete());
proc_->SignalMultiple(maximum_dns_failures() + 5);
@@ -4505,19 +4727,19 @@
std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
// First active job gets two slots.
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("slow_ok1", 80), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("slow_ok1", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
EXPECT_FALSE(responses[0]->complete());
// Next job gets one slot, and waits on another.
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("slow_ok2", 80), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("slow_ok2", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
EXPECT_FALSE(responses[1]->complete());
// Next one is queued.
- responses.emplace_back(
- std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
- HostPortPair("ok", 80), NetLogWithSource(), base::nullopt)));
+ responses.emplace_back(std::make_unique<ResolveHostResponseHelper>(
+ resolver_->CreateRequest(HostPortPair("ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get())));
EXPECT_FALSE(responses[2]->complete());
EXPECT_EQ(3u, num_running_dispatcher_jobs());
@@ -4562,15 +4784,18 @@
HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
proc_->AddRule("h1", ADDRESS_FAMILY_IPV6, "::2");
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("h1", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("h1", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::A;
- ResolveHostResponseHelper v4_response(resolver_->CreateRequest(
- HostPortPair("h1", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper v4_response(
+ resolver_->CreateRequest(HostPortPair("h1", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
parameters.dns_query_type = DnsQueryType::AAAA;
- ResolveHostResponseHelper v6_response(resolver_->CreateRequest(
- HostPortPair("h1", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper v6_response(
+ resolver_->CreateRequest(HostPortPair("h1", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
proc_->SignalMultiple(3u);
@@ -4592,14 +4817,17 @@
NetworkChangeNotifier::CONNECTION_4G);
base::RunLoop().RunUntilIdle(); // Wait for NetworkChangeNotifier.
- ResolveHostResponseHelper no_wifi_response(resolver_->CreateRequest(
- HostPortPair("h1", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper no_wifi_response(
+ resolver_->CreateRequest(HostPortPair("h1", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
parameters.dns_query_type = DnsQueryType::A;
- ResolveHostResponseHelper no_wifi_v4_response(resolver_->CreateRequest(
- HostPortPair("h1", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper no_wifi_v4_response(
+ resolver_->CreateRequest(HostPortPair("h1", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
parameters.dns_query_type = DnsQueryType::AAAA;
- ResolveHostResponseHelper no_wifi_v6_response(resolver_->CreateRequest(
- HostPortPair("h1", 80), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper no_wifi_v6_response(
+ resolver_->CreateRequest(HostPortPair("h1", 80), NetLogWithSource(),
+ parameters, request_context_.get()));
proc_->SignalMultiple(3u);
@@ -4625,8 +4853,9 @@
ChangeDnsConfig(CreateValidDnsConfig());
// NODATA
- ResolveHostResponseHelper no_data_response(resolver_->CreateRequest(
- HostPortPair("empty", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper no_data_response(
+ resolver_->CreateRequest(HostPortPair("empty", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(no_data_response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(no_data_response.request()->GetAddressResults());
HostCache::Key key("empty", DnsQueryType::UNSPECIFIED, 0,
@@ -4640,8 +4869,9 @@
EXPECT_THAT(cache_result->second.ttl(), base::TimeDelta::FromSeconds(86400));
// NXDOMAIN
- ResolveHostResponseHelper no_domain_response(resolver_->CreateRequest(
- HostPortPair("nodomain", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper no_domain_response(
+ resolver_->CreateRequest(HostPortPair("nodomain", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(no_domain_response.result_error(),
IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(no_domain_response.request()->GetAddressResults());
@@ -4663,20 +4893,23 @@
cache_only_parameters.source = HostResolverSource::LOCAL_ONLY;
// Expect cache initially empty.
- ResolveHostResponseHelper cache_miss_response(resolver_->CreateRequest(
- HostPortPair("nodomain", 80), NetLogWithSource(), cache_only_parameters));
+ ResolveHostResponseHelper cache_miss_response(
+ resolver_->CreateRequest(HostPortPair("nodomain", 80), NetLogWithSource(),
+ cache_only_parameters, request_context_.get()));
EXPECT_THAT(cache_miss_response.result_error(), IsError(ERR_DNS_CACHE_MISS));
EXPECT_FALSE(cache_miss_response.request()->GetStaleInfo());
// Populate cache with an error.
- ResolveHostResponseHelper no_domain_response(resolver_->CreateRequest(
- HostPortPair("nodomain", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper no_domain_response(
+ resolver_->CreateRequest(HostPortPair("nodomain", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
EXPECT_THAT(no_domain_response.result_error(),
IsError(ERR_NAME_NOT_RESOLVED));
// Expect the error result can be resolved from the cache.
- ResolveHostResponseHelper cache_hit_response(resolver_->CreateRequest(
- HostPortPair("nodomain", 80), NetLogWithSource(), cache_only_parameters));
+ ResolveHostResponseHelper cache_hit_response(
+ resolver_->CreateRequest(HostPortPair("nodomain", 80), NetLogWithSource(),
+ cache_only_parameters, request_context_.get()));
EXPECT_THAT(cache_hit_response.result_error(),
IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(cache_hit_response.request()->GetStaleInfo().value().is_stale());
@@ -4693,8 +4926,9 @@
UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
set_allow_fallback_to_proctask(false);
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("alias", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("alias", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ASSERT_THAT(response.result_error(), IsOk());
// HostResolver may still give name, but if so, it must be correct.
@@ -4717,8 +4951,9 @@
HostResolver::ResolveHostParameters params;
params.include_canonical_name = true;
params.source = HostResolverSource::DNS;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("alias", 80), NetLogWithSource(), params));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("alias", 80), NetLogWithSource(),
+ params, request_context_.get()));
ASSERT_THAT(response.result_error(), IsOk());
EXPECT_EQ(response.request()->GetAddressResults().value().canonical_name(),
@@ -4739,8 +4974,9 @@
HostResolver::ResolveHostParameters params;
params.include_canonical_name = true;
params.source = HostResolverSource::DNS;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("alias", 80), NetLogWithSource(), params));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("alias", 80), NetLogWithSource(),
+ params, request_context_.get()));
ASSERT_FALSE(response.complete());
base::RunLoop().RunUntilIdle();
dns_client_->CompleteDelayedTransactions();
@@ -4761,8 +4997,9 @@
params.dns_query_type = DnsQueryType::A;
params.include_canonical_name = true;
params.source = HostResolverSource::DNS;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("alias", 80), NetLogWithSource(), params));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("alias", 80), NetLogWithSource(),
+ params, request_context_.get()));
ASSERT_THAT(response.result_error(), IsOk());
EXPECT_EQ(response.request()->GetAddressResults().value().canonical_name(),
"correct");
@@ -4784,7 +5021,8 @@
HostResolver::ResolveHostParameters params;
params.include_canonical_name = true;
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("nx_succeed", 80), NetLogWithSource(), params));
+ HostPortPair("nx_succeed", 80), NetLogWithSource(), params,
+ request_context_.get()));
ASSERT_THAT(response.result_error(), IsOk());
EXPECT_EQ(response.request()->GetAddressResults().value().canonical_name(),
@@ -4853,7 +5091,8 @@
resolver_->SetDnsConfigOverrides(overrides);
ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("dns.example2.com", 80), NetLogWithSource(), base::nullopt));
+ HostPortPair("dns.example2.com", 80), NetLogWithSource(), base::nullopt,
+ request_context_.get()));
ASSERT_THAT(response.result_error(), IsOk());
}
@@ -5177,8 +5416,9 @@
ASSERT_FALSE(overrides.OverridesEverything());
resolver_->SetDnsConfigOverrides(overrides);
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("4slow_ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("4slow_ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ASSERT_FALSE(response.complete());
DnsConfig new_config = original_config;
@@ -5201,8 +5441,9 @@
ASSERT_TRUE(overrides.OverridesEverything());
resolver_->SetDnsConfigOverrides(overrides);
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("4slow_ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("4slow_ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ASSERT_FALSE(response.complete());
DnsConfig new_config = original_config;
@@ -5217,8 +5458,9 @@
// overrides, same as receiving a new DnsConfig from the system.
TEST_F(HostResolverManagerDnsTest, CancelQueriesOnSettingOverrides) {
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("4slow_ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("4slow_ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ASSERT_FALSE(response.complete());
DnsConfigOverrides overrides;
@@ -5236,8 +5478,9 @@
overrides.attempts = 123;
resolver_->SetDnsConfigOverrides(overrides);
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("4slow_ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("4slow_ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ASSERT_FALSE(response.complete());
resolver_->SetDnsConfigOverrides(overrides);
@@ -5254,8 +5497,9 @@
overrides.attempts = 123;
resolver_->SetDnsConfigOverrides(overrides);
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("4slow_ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("4slow_ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ASSERT_FALSE(response.complete());
resolver_->SetDnsConfigOverrides(DnsConfigOverrides());
@@ -5268,8 +5512,9 @@
TEST_F(HostResolverManagerDnsTest,
CancelQueriesOnClearingOverrides_NoOverrides) {
ChangeDnsConfig(CreateValidDnsConfig());
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("4slow_ok", 80), NetLogWithSource(), base::nullopt));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("4slow_ok", 80), NetLogWithSource(),
+ base::nullopt, request_context_.get()));
ASSERT_FALSE(response.complete());
resolver_->SetDnsConfigOverrides(DnsConfigOverrides());
@@ -5343,8 +5588,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::TXT;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetHostnameResults());
@@ -5379,8 +5625,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::TXT;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5404,8 +5651,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::TXT;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5429,8 +5677,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::TXT;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_DNS_TIMED_OUT));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5454,8 +5703,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::TXT;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5479,8 +5729,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::TXT;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5501,8 +5752,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::TXT;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5524,8 +5776,9 @@
parameters.dns_query_type = DnsQueryType::TXT;
// Responses for the wrong type should be ignored.
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("ok", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("ok", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5556,8 +5809,9 @@
parameters.source = HostResolverSource::DNS;
parameters.dns_query_type = DnsQueryType::TXT;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetHostnameResults());
@@ -5588,8 +5842,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::PTR;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5614,8 +5869,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::PTR;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("8.8.8.8", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("8.8.8.8", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5643,8 +5899,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::PTR;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5668,8 +5925,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::PTR;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5693,8 +5951,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::PTR;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_DNS_TIMED_OUT));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5718,8 +5977,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::PTR;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5743,8 +6003,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::PTR;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5765,8 +6026,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::PTR;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5788,8 +6050,9 @@
parameters.dns_query_type = DnsQueryType::PTR;
// Responses for the wrong type should be ignored.
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("ok", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("ok", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5814,8 +6077,9 @@
parameters.source = HostResolverSource::DNS;
parameters.dns_query_type = DnsQueryType::PTR;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5843,8 +6107,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::SRV;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5886,8 +6151,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::SRV;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5915,8 +6181,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::SRV;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5940,8 +6207,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::SRV;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5965,8 +6233,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::SRV;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_DNS_TIMED_OUT));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -5990,8 +6259,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::SRV;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -6015,8 +6285,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::SRV;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -6037,8 +6308,9 @@
HostResolver::ResolveHostParameters parameters;
parameters.dns_query_type = DnsQueryType::SRV;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -6060,8 +6332,9 @@
parameters.dns_query_type = DnsQueryType::SRV;
// Responses for the wrong type should be ignored.
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("ok", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("ok", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -6090,8 +6363,9 @@
parameters.source = HostResolverSource::DNS;
parameters.dns_query_type = DnsQueryType::SRV;
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 108), NetLogWithSource(), parameters));
+ ResolveHostResponseHelper response(
+ resolver_->CreateRequest(HostPortPair("host", 108), NetLogWithSource(),
+ parameters, request_context_.get()));
EXPECT_THAT(response.result_error(), IsOk());
EXPECT_FALSE(response.request()->GetAddressResults());
EXPECT_FALSE(response.request()->GetTextResults());
@@ -6116,24 +6390,4 @@
HostPortPair("google.com", 5)));
}
-TEST_F(HostResolverManagerDnsTest, SetRequestContext) {
- URLRequestContext context;
-
- MockDnsClientRuleList rules;
- rules.emplace_back("host", dns_protocol::kTypeA, SecureDnsMode::AUTOMATIC,
- MockDnsClientRule::Result(MockDnsClientRule::OK),
- false /* delay */, &context);
- rules.emplace_back("host", dns_protocol::kTypeAAAA, SecureDnsMode::AUTOMATIC,
- MockDnsClientRule::Result(MockDnsClientRule::OK),
- false /* delay */, &context);
-
- CreateResolver();
- resolver_->SetRequestContext(&context);
- UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
-
- ResolveHostResponseHelper response(resolver_->CreateRequest(
- HostPortPair("host", 109), NetLogWithSource(), base::nullopt));
- EXPECT_THAT(response.result_error(), IsOk());
-}
-
} // namespace net
diff --git a/net/url_request/http_with_dns_over_https_unittest.cc b/net/url_request/http_with_dns_over_https_unittest.cc
index 6e09c7b..bbf6e3e 100644
--- a/net/url_request/http_with_dns_over_https_unittest.cc
+++ b/net/url_request/http_with_dns_over_https_unittest.cc
@@ -71,7 +71,6 @@
config.dns_over_https_servers.emplace_back(url.spec(), true /* use_post */);
dns_client->SetConfig(config);
resolver_->SetRequestContext(&request_context_);
- resolver_->GetManagerForTesting()->SetRequestContext(&request_context_);
resolver_->SetProcParamsForTesting(
ProcTaskParams(new TestHostResolverProc(), 1));
resolver_->SetDnsClientForTesting(std::move(dns_client));
diff --git a/services/network/network_service.cc b/services/network/network_service.cc
index 7a8cae3f..ab8671b 100644
--- a/services/network/network_service.cc
+++ b/services/network/network_service.cc
@@ -458,27 +458,13 @@
return;
}
- for (auto* network_context : network_contexts_) {
- if (!network_context->IsPrimaryNetworkContext())
- continue;
-
- host_resolver_manager_->SetRequestContext(
- network_context->url_request_context());
-
- net::DnsConfigOverrides overrides;
- overrides.dns_over_https_servers.emplace();
- for (const auto& doh_server : *dns_over_https_servers) {
- overrides.dns_over_https_servers.value().emplace_back(
- doh_server->server_template, doh_server->use_post);
- }
- host_resolver_manager_->SetDnsConfigOverrides(overrides);
-
- return;
+ net::DnsConfigOverrides overrides;
+ overrides.dns_over_https_servers.emplace();
+ for (const auto& doh_server : *dns_over_https_servers) {
+ overrides.dns_over_https_servers.value().emplace_back(
+ doh_server->server_template, doh_server->use_post);
}
-
- // Execution should generally not reach this line, but could run into races
- // with teardown, or restarting a crashed network process, that could
- // theoretically result in reaching it.
+ host_resolver_manager_->SetDnsConfigOverrides(overrides);
}
void NetworkService::DisableQuic() {
@@ -691,6 +677,16 @@
}
void NetworkService::DestroyNetworkContexts() {
+ // If DNS over HTTPS is enabled, the HostResolver is currently using
+ // NetworkContexts to do DNS lookups, so need to tell the HostResolver
+ // to stop using DNS over HTTPS before destroying any NetworkContexts.
+ // The SetDnsConfigOverrides() call will will fail any in-progress DNS
+ // lookups, but only if there are current config overrides (which there will
+ // be if DNS over HTTPS is currently enabled).
+ if (host_resolver_manager_) {
+ host_resolver_manager_->SetDnsConfigOverrides(net::DnsConfigOverrides());
+ }
+
// Delete NetworkContexts. If there's a primary NetworkContext, it must be
// deleted after all other NetworkContexts, to avoid use-after-frees.
for (auto it = owned_network_contexts_.begin();
@@ -701,17 +697,6 @@
owned_network_contexts_.erase(last);
}
- // If DNS over HTTPS is enabled, the HostResolver is currently using the
- // primary NetworkContext to do DNS lookups, so need to tell the HostResolver
- // to stop using DNS over HTTPS before destroying the primary NetworkContext.
- // The SetDnsConfigOverrides() call will will fail any in-progress DNS
- // lookups, but only if there are current config overrides (which there will
- // be if DNS over HTTPS is currently enabled).
- if (host_resolver_manager_) {
- host_resolver_manager_->SetDnsConfigOverrides(net::DnsConfigOverrides());
- host_resolver_manager_->SetRequestContext(nullptr);
- }
-
DCHECK_LE(owned_network_contexts_.size(), 1u);
owned_network_contexts_.clear();
}
diff --git a/services/network/network_service_unittest.cc b/services/network/network_service_unittest.cc
index 6cf7f7b..68d6e1d4 100644
--- a/services/network/network_service_unittest.cc
+++ b/services/network/network_service_unittest.cc
@@ -550,51 +550,6 @@
service()->host_resolver_manager()->GetDnsOverHttpsServersForTesting());
}
-// Make sure that enabling DNS over HTTP without a primary NetworkContext fails.
-TEST_F(NetworkServiceTest,
- DnsOverHttpsEnableDoesNothingWithoutPrimaryNetworkContext) {
- // HostResolver::GetDnsClientForTesting() returns nullptr if the stub resolver
- // is disabled.
- EXPECT_FALSE(service()->host_resolver_manager()->GetDnsConfigAsValue());
-
- // Try to enable DnsClient and DNS over HTTPS. Only the first should take
- // effect.
- std::vector<mojom::DnsOverHttpsServerPtr> dns_over_https_servers;
- mojom::DnsOverHttpsServerPtr dns_over_https_server =
- mojom::DnsOverHttpsServer::New();
- dns_over_https_server->server_template = "https://foo/{?dns}";
- dns_over_https_servers.emplace_back(std::move(dns_over_https_server));
- service()->ConfigureStubHostResolver(true /* stub_resolver_enabled */,
- std::move(dns_over_https_servers));
- // DnsClient is enabled.
- EXPECT_TRUE(service()->host_resolver_manager()->GetDnsConfigAsValue());
- // DNS over HTTPS is not.
- EXPECT_FALSE(
- service()->host_resolver_manager()->GetDnsOverHttpsServersForTesting());
-
- // Create a NetworkContext that is not the primary one.
- mojom::NetworkContextPtr network_context;
- service()->CreateNetworkContext(mojo::MakeRequest(&network_context),
- CreateContextParams());
- // There should be no change in host resolver state.
- EXPECT_TRUE(service()->host_resolver_manager()->GetDnsConfigAsValue());
- EXPECT_FALSE(
- service()->host_resolver_manager()->GetDnsOverHttpsServersForTesting());
-
- // Try to enable DNS over HTTPS again, which should not work, since there's
- // still no primary NetworkContext.
- dns_over_https_servers.clear();
- dns_over_https_server = mojom::DnsOverHttpsServer::New();
- dns_over_https_server->server_template = "https://foo2/{?dns}";
- dns_over_https_servers.emplace_back(std::move(dns_over_https_server));
- service()->ConfigureStubHostResolver(true /* stub_resolver_enabled */,
- std::move(dns_over_https_servers));
- // There should be no change in host resolver state.
- EXPECT_TRUE(service()->host_resolver_manager()->GetDnsConfigAsValue());
- EXPECT_FALSE(
- service()->host_resolver_manager()->GetDnsOverHttpsServersForTesting());
-}
-
#endif // !defined(OS_IOS)
// |ntlm_v2_enabled| is only supported on POSIX platforms.
