| Index: net/dns/host_resolver_impl.cc
|
| diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc
|
| deleted file mode 100644
|
| index 6c0a154971a4fe2a4386051bef361ac7188046fc..0000000000000000000000000000000000000000
|
| --- a/net/dns/host_resolver_impl.cc
|
| +++ /dev/null
|
| @@ -1,2372 +0,0 @@
|
| -// Copyright (c) 2012 The Chromium Authors. All rights reserved.
|
| -// Use of this source code is governed by a BSD-style license that can be
|
| -// found in the LICENSE file.
|
| -
|
| -#include "net/dns/host_resolver_impl.h"
|
| -
|
| -#if defined(OS_WIN)
|
| -#include <Winsock2.h>
|
| -#elif defined(OS_POSIX)
|
| -#include <netdb.h>
|
| -#endif
|
| -
|
| -#include <cmath>
|
| -#include <utility>
|
| -#include <vector>
|
| -
|
| -#include "base/basictypes.h"
|
| -#include "base/bind.h"
|
| -#include "base/bind_helpers.h"
|
| -#include "base/callback.h"
|
| -#include "base/compiler_specific.h"
|
| -#include "base/debug/debugger.h"
|
| -#include "base/debug/stack_trace.h"
|
| -#include "base/message_loop/message_loop_proxy.h"
|
| -#include "base/metrics/field_trial.h"
|
| -#include "base/metrics/histogram.h"
|
| -#include "base/profiler/scoped_tracker.h"
|
| -#include "base/stl_util.h"
|
| -#include "base/strings/string_util.h"
|
| -#include "base/strings/utf_string_conversions.h"
|
| -#include "base/threading/worker_pool.h"
|
| -#include "base/time/time.h"
|
| -#include "base/values.h"
|
| -#include "net/base/address_family.h"
|
| -#include "net/base/address_list.h"
|
| -#include "net/base/dns_reloader.h"
|
| -#include "net/base/dns_util.h"
|
| -#include "net/base/host_port_pair.h"
|
| -#include "net/base/ip_endpoint.h"
|
| -#include "net/base/net_errors.h"
|
| -#include "net/base/net_log.h"
|
| -#include "net/base/net_util.h"
|
| -#include "net/dns/address_sorter.h"
|
| -#include "net/dns/dns_client.h"
|
| -#include "net/dns/dns_config_service.h"
|
| -#include "net/dns/dns_protocol.h"
|
| -#include "net/dns/dns_response.h"
|
| -#include "net/dns/dns_transaction.h"
|
| -#include "net/dns/host_resolver_proc.h"
|
| -#include "net/socket/client_socket_factory.h"
|
| -#include "net/udp/datagram_client_socket.h"
|
| -#include "url/url_canon_ip.h"
|
| -
|
| -#if defined(OS_WIN)
|
| -#include "net/base/winsock_init.h"
|
| -#endif
|
| -
|
| -namespace net {
|
| -
|
| -namespace {
|
| -
|
| -// Limit the size of hostnames that will be resolved to combat issues in
|
| -// some platform's resolvers.
|
| -const size_t kMaxHostLength = 4096;
|
| -
|
| -// Default TTL for successful resolutions with ProcTask.
|
| -const unsigned kCacheEntryTTLSeconds = 60;
|
| -
|
| -// Default TTL for unsuccessful resolutions with ProcTask.
|
| -const unsigned kNegativeCacheEntryTTLSeconds = 0;
|
| -
|
| -// Minimum TTL for successful resolutions with DnsTask.
|
| -const unsigned kMinimumTTLSeconds = kCacheEntryTTLSeconds;
|
| -
|
| -// We use a separate histogram name for each platform to facilitate the
|
| -// display of error codes by their symbolic name (since each platform has
|
| -// different mappings).
|
| -const char kOSErrorsForGetAddrinfoHistogramName[] =
|
| -#if defined(OS_WIN)
|
| - "Net.OSErrorsForGetAddrinfo_Win";
|
| -#elif defined(OS_MACOSX)
|
| - "Net.OSErrorsForGetAddrinfo_Mac";
|
| -#elif defined(OS_LINUX)
|
| - "Net.OSErrorsForGetAddrinfo_Linux";
|
| -#else
|
| - "Net.OSErrorsForGetAddrinfo";
|
| -#endif
|
| -
|
| -// Gets a list of the likely error codes that getaddrinfo() can return
|
| -// (non-exhaustive). These are the error codes that we will track via
|
| -// a histogram.
|
| -std::vector<int> GetAllGetAddrinfoOSErrors() {
|
| - int os_errors[] = {
|
| -#if defined(OS_POSIX)
|
| -#if !defined(OS_FREEBSD)
|
| -#if !defined(OS_ANDROID)
|
| - // EAI_ADDRFAMILY has been declared obsolete in Android's and
|
| - // FreeBSD's netdb.h.
|
| - EAI_ADDRFAMILY,
|
| -#endif
|
| - // EAI_NODATA has been declared obsolete in FreeBSD's netdb.h.
|
| - EAI_NODATA,
|
| -#endif
|
| - EAI_AGAIN,
|
| - EAI_BADFLAGS,
|
| - EAI_FAIL,
|
| - EAI_FAMILY,
|
| - EAI_MEMORY,
|
| - EAI_NONAME,
|
| - EAI_SERVICE,
|
| - EAI_SOCKTYPE,
|
| - EAI_SYSTEM,
|
| -#elif defined(OS_WIN)
|
| - // See: http://msdn.microsoft.com/en-us/library/ms738520(VS.85).aspx
|
| - WSA_NOT_ENOUGH_MEMORY,
|
| - WSAEAFNOSUPPORT,
|
| - WSAEINVAL,
|
| - WSAESOCKTNOSUPPORT,
|
| - WSAHOST_NOT_FOUND,
|
| - WSANO_DATA,
|
| - WSANO_RECOVERY,
|
| - WSANOTINITIALISED,
|
| - WSATRY_AGAIN,
|
| - WSATYPE_NOT_FOUND,
|
| - // The following are not in doc, but might be to appearing in results :-(.
|
| - WSA_INVALID_HANDLE,
|
| -#endif
|
| - };
|
| -
|
| - // Ensure all errors are positive, as histogram only tracks positive values.
|
| - for (size_t i = 0; i < arraysize(os_errors); ++i) {
|
| - os_errors[i] = std::abs(os_errors[i]);
|
| - }
|
| -
|
| - return base::CustomHistogram::ArrayToCustomRanges(os_errors,
|
| - arraysize(os_errors));
|
| -}
|
| -
|
| -enum DnsResolveStatus {
|
| - RESOLVE_STATUS_DNS_SUCCESS = 0,
|
| - RESOLVE_STATUS_PROC_SUCCESS,
|
| - RESOLVE_STATUS_FAIL,
|
| - RESOLVE_STATUS_SUSPECT_NETBIOS,
|
| - RESOLVE_STATUS_MAX
|
| -};
|
| -
|
| -void UmaAsyncDnsResolveStatus(DnsResolveStatus result) {
|
| - UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ResolveStatus",
|
| - result,
|
| - RESOLVE_STATUS_MAX);
|
| -}
|
| -
|
| -bool ResemblesNetBIOSName(const std::string& hostname) {
|
| - return (hostname.size() < 16) && (hostname.find('.') == std::string::npos);
|
| -}
|
| -
|
| -// True if |hostname| ends with either ".local" or ".local.".
|
| -bool ResemblesMulticastDNSName(const std::string& hostname) {
|
| - DCHECK(!hostname.empty());
|
| - const char kSuffix[] = ".local.";
|
| - const size_t kSuffixLen = sizeof(kSuffix) - 1;
|
| - const size_t kSuffixLenTrimmed = kSuffixLen - 1;
|
| - if (hostname[hostname.size() - 1] == '.') {
|
| - return hostname.size() > kSuffixLen &&
|
| - !hostname.compare(hostname.size() - kSuffixLen, kSuffixLen, kSuffix);
|
| - }
|
| - return hostname.size() > kSuffixLenTrimmed &&
|
| - !hostname.compare(hostname.size() - kSuffixLenTrimmed, kSuffixLenTrimmed,
|
| - kSuffix, kSuffixLenTrimmed);
|
| -}
|
| -
|
| -// Attempts to connect a UDP socket to |dest|:53.
|
| -bool IsGloballyReachable(const IPAddressNumber& dest,
|
| - const BoundNetLog& net_log) {
|
| - scoped_ptr<DatagramClientSocket> socket(
|
| - ClientSocketFactory::GetDefaultFactory()->CreateDatagramClientSocket(
|
| - DatagramSocket::DEFAULT_BIND,
|
| - RandIntCallback(),
|
| - net_log.net_log(),
|
| - net_log.source()));
|
| - int rv = socket->Connect(IPEndPoint(dest, 53));
|
| - if (rv != OK)
|
| - return false;
|
| - IPEndPoint endpoint;
|
| - rv = socket->GetLocalAddress(&endpoint);
|
| - if (rv != OK)
|
| - return false;
|
| - DCHECK_EQ(ADDRESS_FAMILY_IPV6, endpoint.GetFamily());
|
| - const IPAddressNumber& address = endpoint.address();
|
| - bool is_link_local = (address[0] == 0xFE) && ((address[1] & 0xC0) == 0x80);
|
| - if (is_link_local)
|
| - return false;
|
| - const uint8 kTeredoPrefix[] = { 0x20, 0x01, 0, 0 };
|
| - bool is_teredo = std::equal(kTeredoPrefix,
|
| - kTeredoPrefix + arraysize(kTeredoPrefix),
|
| - address.begin());
|
| - if (is_teredo)
|
| - return false;
|
| - return true;
|
| -}
|
| -
|
| -// Provide a common macro to simplify code and readability. We must use a
|
| -// macro as the underlying HISTOGRAM macro creates static variables.
|
| -#define DNS_HISTOGRAM(name, time) UMA_HISTOGRAM_CUSTOM_TIMES(name, time, \
|
| - base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromHours(1), 100)
|
| -
|
| -// A macro to simplify code and readability.
|
| -#define DNS_HISTOGRAM_BY_PRIORITY(basename, priority, time) \
|
| - do { \
|
| - switch (priority) { \
|
| - case HIGHEST: DNS_HISTOGRAM(basename "_HIGHEST", time); break; \
|
| - case MEDIUM: DNS_HISTOGRAM(basename "_MEDIUM", time); break; \
|
| - case LOW: DNS_HISTOGRAM(basename "_LOW", time); break; \
|
| - case LOWEST: DNS_HISTOGRAM(basename "_LOWEST", time); break; \
|
| - case IDLE: DNS_HISTOGRAM(basename "_IDLE", time); break; \
|
| - default: NOTREACHED(); break; \
|
| - } \
|
| - DNS_HISTOGRAM(basename, time); \
|
| - } while (0)
|
| -
|
| -// Record time from Request creation until a valid DNS response.
|
| -void RecordTotalTime(bool had_dns_config,
|
| - bool speculative,
|
| - base::TimeDelta duration) {
|
| - if (had_dns_config) {
|
| - if (speculative) {
|
| - DNS_HISTOGRAM("AsyncDNS.TotalTime_speculative", duration);
|
| - } else {
|
| - DNS_HISTOGRAM("AsyncDNS.TotalTime", duration);
|
| - }
|
| - } else {
|
| - if (speculative) {
|
| - DNS_HISTOGRAM("DNS.TotalTime_speculative", duration);
|
| - } else {
|
| - DNS_HISTOGRAM("DNS.TotalTime", duration);
|
| - }
|
| - }
|
| -}
|
| -
|
| -void RecordTTL(base::TimeDelta ttl) {
|
| - UMA_HISTOGRAM_CUSTOM_TIMES("AsyncDNS.TTL", ttl,
|
| - base::TimeDelta::FromSeconds(1),
|
| - base::TimeDelta::FromDays(1), 100);
|
| -}
|
| -
|
| -bool ConfigureAsyncDnsNoFallbackFieldTrial() {
|
| - const bool kDefault = false;
|
| -
|
| - // Configure the AsyncDns field trial as follows:
|
| - // groups AsyncDnsNoFallbackA and AsyncDnsNoFallbackB: return true,
|
| - // groups AsyncDnsA and AsyncDnsB: return false,
|
| - // groups SystemDnsA and SystemDnsB: return false,
|
| - // otherwise (trial absent): return default.
|
| - std::string group_name = base::FieldTrialList::FindFullName("AsyncDns");
|
| - if (!group_name.empty())
|
| - return StartsWithASCII(group_name, "AsyncDnsNoFallback", false);
|
| - return kDefault;
|
| -}
|
| -
|
| -//-----------------------------------------------------------------------------
|
| -
|
| -AddressList EnsurePortOnAddressList(const AddressList& list, uint16 port) {
|
| - if (list.empty() || list.front().port() == port)
|
| - return list;
|
| - return AddressList::CopyWithPort(list, port);
|
| -}
|
| -
|
| -// Returns true if |addresses| contains only IPv4 loopback addresses.
|
| -bool IsAllIPv4Loopback(const AddressList& addresses) {
|
| - for (unsigned i = 0; i < addresses.size(); ++i) {
|
| - const IPAddressNumber& address = addresses[i].address();
|
| - switch (addresses[i].GetFamily()) {
|
| - case ADDRESS_FAMILY_IPV4:
|
| - if (address[0] != 127)
|
| - return false;
|
| - break;
|
| - case ADDRESS_FAMILY_IPV6:
|
| - return false;
|
| - default:
|
| - NOTREACHED();
|
| - return false;
|
| - }
|
| - }
|
| - return true;
|
| -}
|
| -
|
| -// Creates NetLog parameters when the resolve failed.
|
| -base::Value* NetLogProcTaskFailedCallback(uint32 attempt_number,
|
| - int net_error,
|
| - int os_error,
|
| - NetLog::LogLevel /* log_level */) {
|
| - base::DictionaryValue* dict = new base::DictionaryValue();
|
| - if (attempt_number)
|
| - dict->SetInteger("attempt_number", attempt_number);
|
| -
|
| - dict->SetInteger("net_error", net_error);
|
| -
|
| - if (os_error) {
|
| - dict->SetInteger("os_error", os_error);
|
| -#if defined(OS_POSIX)
|
| - dict->SetString("os_error_string", gai_strerror(os_error));
|
| -#elif defined(OS_WIN)
|
| - // Map the error code to a human-readable string.
|
| - LPWSTR error_string = NULL;
|
| - FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
| - 0, // Use the internal message table.
|
| - os_error,
|
| - 0, // Use default language.
|
| - (LPWSTR)&error_string,
|
| - 0, // Buffer size.
|
| - 0); // Arguments (unused).
|
| - dict->SetString("os_error_string", base::WideToUTF8(error_string));
|
| - LocalFree(error_string);
|
| -#endif
|
| - }
|
| -
|
| - return dict;
|
| -}
|
| -
|
| -// Creates NetLog parameters when the DnsTask failed.
|
| -base::Value* NetLogDnsTaskFailedCallback(int net_error,
|
| - int dns_error,
|
| - NetLog::LogLevel /* log_level */) {
|
| - base::DictionaryValue* dict = new base::DictionaryValue();
|
| - dict->SetInteger("net_error", net_error);
|
| - if (dns_error)
|
| - dict->SetInteger("dns_error", dns_error);
|
| - return dict;
|
| -};
|
| -
|
| -// Creates NetLog parameters containing the information in a RequestInfo object,
|
| -// along with the associated NetLog::Source.
|
| -base::Value* NetLogRequestInfoCallback(const HostResolver::RequestInfo* info,
|
| - NetLog::LogLevel /* log_level */) {
|
| - base::DictionaryValue* dict = new base::DictionaryValue();
|
| -
|
| - dict->SetString("host", info->host_port_pair().ToString());
|
| - dict->SetInteger("address_family",
|
| - static_cast<int>(info->address_family()));
|
| - dict->SetBoolean("allow_cached_response", info->allow_cached_response());
|
| - dict->SetBoolean("is_speculative", info->is_speculative());
|
| - return dict;
|
| -}
|
| -
|
| -// Creates NetLog parameters for the creation of a HostResolverImpl::Job.
|
| -base::Value* NetLogJobCreationCallback(const NetLog::Source& source,
|
| - const std::string* host,
|
| - NetLog::LogLevel /* log_level */) {
|
| - base::DictionaryValue* dict = new base::DictionaryValue();
|
| - source.AddToEventParameters(dict);
|
| - dict->SetString("host", *host);
|
| - return dict;
|
| -}
|
| -
|
| -// Creates NetLog parameters for HOST_RESOLVER_IMPL_JOB_ATTACH/DETACH events.
|
| -base::Value* NetLogJobAttachCallback(const NetLog::Source& source,
|
| - RequestPriority priority,
|
| - NetLog::LogLevel /* log_level */) {
|
| - base::DictionaryValue* dict = new base::DictionaryValue();
|
| - source.AddToEventParameters(dict);
|
| - dict->SetString("priority", RequestPriorityToString(priority));
|
| - return dict;
|
| -}
|
| -
|
| -// Creates NetLog parameters for the DNS_CONFIG_CHANGED event.
|
| -base::Value* NetLogDnsConfigCallback(const DnsConfig* config,
|
| - NetLog::LogLevel /* log_level */) {
|
| - return config->ToValue();
|
| -}
|
| -
|
| -// The logging routines are defined here because some requests are resolved
|
| -// without a Request object.
|
| -
|
| -// Logs when a request has just been started.
|
| -void LogStartRequest(const BoundNetLog& source_net_log,
|
| - const HostResolver::RequestInfo& info) {
|
| - source_net_log.BeginEvent(
|
| - NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST,
|
| - base::Bind(&NetLogRequestInfoCallback, &info));
|
| -}
|
| -
|
| -// Logs when a request has just completed (before its callback is run).
|
| -void LogFinishRequest(const BoundNetLog& source_net_log,
|
| - const HostResolver::RequestInfo& info,
|
| - int net_error) {
|
| - source_net_log.EndEventWithNetErrorCode(
|
| - NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST, net_error);
|
| -}
|
| -
|
| -// Logs when a request has been cancelled.
|
| -void LogCancelRequest(const BoundNetLog& source_net_log,
|
| - const HostResolverImpl::RequestInfo& info) {
|
| - source_net_log.AddEvent(NetLog::TYPE_CANCELLED);
|
| - source_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST);
|
| -}
|
| -
|
| -//-----------------------------------------------------------------------------
|
| -
|
| -// Keeps track of the highest priority.
|
| -class PriorityTracker {
|
| - public:
|
| - explicit PriorityTracker(RequestPriority initial_priority)
|
| - : highest_priority_(initial_priority), total_count_(0) {
|
| - memset(counts_, 0, sizeof(counts_));
|
| - }
|
| -
|
| - RequestPriority highest_priority() const {
|
| - return highest_priority_;
|
| - }
|
| -
|
| - size_t total_count() const {
|
| - return total_count_;
|
| - }
|
| -
|
| - void Add(RequestPriority req_priority) {
|
| - ++total_count_;
|
| - ++counts_[req_priority];
|
| - if (highest_priority_ < req_priority)
|
| - highest_priority_ = req_priority;
|
| - }
|
| -
|
| - void Remove(RequestPriority req_priority) {
|
| - DCHECK_GT(total_count_, 0u);
|
| - DCHECK_GT(counts_[req_priority], 0u);
|
| - --total_count_;
|
| - --counts_[req_priority];
|
| - size_t i;
|
| - for (i = highest_priority_; i > MINIMUM_PRIORITY && !counts_[i]; --i);
|
| - highest_priority_ = static_cast<RequestPriority>(i);
|
| -
|
| - // In absence of requests, default to MINIMUM_PRIORITY.
|
| - if (total_count_ == 0)
|
| - DCHECK_EQ(MINIMUM_PRIORITY, highest_priority_);
|
| - }
|
| -
|
| - private:
|
| - RequestPriority highest_priority_;
|
| - size_t total_count_;
|
| - size_t counts_[NUM_PRIORITIES];
|
| -};
|
| -
|
| -} // namespace
|
| -
|
| -//-----------------------------------------------------------------------------
|
| -
|
| -const unsigned HostResolverImpl::kMaximumDnsFailures = 16;
|
| -
|
| -// Holds the data for a request that could not be completed synchronously.
|
| -// It is owned by a Job. Canceled Requests are only marked as canceled rather
|
| -// than removed from the Job's |requests_| list.
|
| -class HostResolverImpl::Request {
|
| - public:
|
| - Request(const BoundNetLog& source_net_log,
|
| - const RequestInfo& info,
|
| - RequestPriority priority,
|
| - const CompletionCallback& callback,
|
| - AddressList* addresses)
|
| - : source_net_log_(source_net_log),
|
| - info_(info),
|
| - priority_(priority),
|
| - job_(NULL),
|
| - callback_(callback),
|
| - addresses_(addresses),
|
| - request_time_(base::TimeTicks::Now()) {}
|
| -
|
| - // Mark the request as canceled.
|
| - void MarkAsCanceled() {
|
| - job_ = NULL;
|
| - addresses_ = NULL;
|
| - callback_.Reset();
|
| - }
|
| -
|
| - bool was_canceled() const {
|
| - return callback_.is_null();
|
| - }
|
| -
|
| - void set_job(Job* job) {
|
| - DCHECK(job);
|
| - // Identify which job the request is waiting on.
|
| - job_ = job;
|
| - }
|
| -
|
| - // Prepare final AddressList and call completion callback.
|
| - void OnComplete(int error, const AddressList& addr_list) {
|
| - // TODO(vadimt): Remove ScopedTracker below once crbug.com/436634 is fixed.
|
| - tracked_objects::ScopedTracker tracking_profile(
|
| - FROM_HERE_WITH_EXPLICIT_FUNCTION(
|
| - "436634 HostResolverImpl::Request::OnComplete"));
|
| -
|
| - DCHECK(!was_canceled());
|
| - if (error == OK)
|
| - *addresses_ = EnsurePortOnAddressList(addr_list, info_.port());
|
| - CompletionCallback callback = callback_;
|
| - MarkAsCanceled();
|
| - callback.Run(error);
|
| - }
|
| -
|
| - Job* job() const {
|
| - return job_;
|
| - }
|
| -
|
| - // NetLog for the source, passed in HostResolver::Resolve.
|
| - const BoundNetLog& source_net_log() {
|
| - return source_net_log_;
|
| - }
|
| -
|
| - const RequestInfo& info() const {
|
| - return info_;
|
| - }
|
| -
|
| - RequestPriority priority() const { return priority_; }
|
| -
|
| - base::TimeTicks request_time() const { return request_time_; }
|
| -
|
| - private:
|
| - const BoundNetLog source_net_log_;
|
| -
|
| - // The request info that started the request.
|
| - const RequestInfo info_;
|
| -
|
| - // TODO(akalin): Support reprioritization.
|
| - const RequestPriority priority_;
|
| -
|
| - // The resolve job that this request is dependent on.
|
| - Job* job_;
|
| -
|
| - // The user's callback to invoke when the request completes.
|
| - CompletionCallback callback_;
|
| -
|
| - // The address list to save result into.
|
| - AddressList* addresses_;
|
| -
|
| - const base::TimeTicks request_time_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(Request);
|
| -};
|
| -
|
| -//------------------------------------------------------------------------------
|
| -
|
| -// Calls HostResolverProc on the WorkerPool. Performs retries if necessary.
|
| -//
|
| -// Whenever we try to resolve the host, we post a delayed task to check if host
|
| -// resolution (OnLookupComplete) is completed or not. If the original attempt
|
| -// hasn't completed, then we start another attempt for host resolution. We take
|
| -// the results from the first attempt that finishes and ignore the results from
|
| -// all other attempts.
|
| -//
|
| -// TODO(szym): Move to separate source file for testing and mocking.
|
| -//
|
| -class HostResolverImpl::ProcTask
|
| - : public base::RefCountedThreadSafe<HostResolverImpl::ProcTask> {
|
| - public:
|
| - typedef base::Callback<void(int net_error,
|
| - const AddressList& addr_list)> Callback;
|
| -
|
| - ProcTask(const Key& key,
|
| - const ProcTaskParams& params,
|
| - const Callback& callback,
|
| - const BoundNetLog& job_net_log)
|
| - : key_(key),
|
| - params_(params),
|
| - callback_(callback),
|
| - origin_loop_(base::MessageLoopProxy::current()),
|
| - attempt_number_(0),
|
| - completed_attempt_number_(0),
|
| - completed_attempt_error_(ERR_UNEXPECTED),
|
| - had_non_speculative_request_(false),
|
| - net_log_(job_net_log) {
|
| - if (!params_.resolver_proc.get())
|
| - params_.resolver_proc = HostResolverProc::GetDefault();
|
| - // If default is unset, use the system proc.
|
| - if (!params_.resolver_proc.get())
|
| - params_.resolver_proc = new SystemHostResolverProc();
|
| - }
|
| -
|
| - void Start() {
|
| - DCHECK(origin_loop_->BelongsToCurrentThread());
|
| - net_log_.BeginEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK);
|
| - StartLookupAttempt();
|
| - }
|
| -
|
| - // Cancels this ProcTask. It will be orphaned. Any outstanding resolve
|
| - // attempts running on worker threads will continue running. Only once all the
|
| - // attempts complete will the final reference to this ProcTask be released.
|
| - void Cancel() {
|
| - DCHECK(origin_loop_->BelongsToCurrentThread());
|
| -
|
| - if (was_canceled() || was_completed())
|
| - return;
|
| -
|
| - callback_.Reset();
|
| - net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK);
|
| - }
|
| -
|
| - void set_had_non_speculative_request() {
|
| - DCHECK(origin_loop_->BelongsToCurrentThread());
|
| - had_non_speculative_request_ = true;
|
| - }
|
| -
|
| - bool was_canceled() const {
|
| - DCHECK(origin_loop_->BelongsToCurrentThread());
|
| - return callback_.is_null();
|
| - }
|
| -
|
| - bool was_completed() const {
|
| - DCHECK(origin_loop_->BelongsToCurrentThread());
|
| - return completed_attempt_number_ > 0;
|
| - }
|
| -
|
| - private:
|
| - friend class base::RefCountedThreadSafe<ProcTask>;
|
| - ~ProcTask() {}
|
| -
|
| - void StartLookupAttempt() {
|
| - DCHECK(origin_loop_->BelongsToCurrentThread());
|
| - base::TimeTicks start_time = base::TimeTicks::Now();
|
| - ++attempt_number_;
|
| - // Dispatch the lookup attempt to a worker thread.
|
| - if (!base::WorkerPool::PostTask(
|
| - FROM_HERE,
|
| - base::Bind(&ProcTask::DoLookup, this, start_time, attempt_number_),
|
| - true)) {
|
| - NOTREACHED();
|
| -
|
| - // Since we could be running within Resolve() right now, we can't just
|
| - // call OnLookupComplete(). Instead we must wait until Resolve() has
|
| - // returned (IO_PENDING).
|
| - origin_loop_->PostTask(
|
| - FROM_HERE,
|
| - base::Bind(&ProcTask::OnLookupComplete, this, AddressList(),
|
| - start_time, attempt_number_, ERR_UNEXPECTED, 0));
|
| - return;
|
| - }
|
| -
|
| - net_log_.AddEvent(
|
| - NetLog::TYPE_HOST_RESOLVER_IMPL_ATTEMPT_STARTED,
|
| - NetLog::IntegerCallback("attempt_number", attempt_number_));
|
| -
|
| - // If we don't get the results within a given time, RetryIfNotComplete
|
| - // will start a new attempt on a different worker thread if none of our
|
| - // outstanding attempts have completed yet.
|
| - if (attempt_number_ <= params_.max_retry_attempts) {
|
| - origin_loop_->PostDelayedTask(
|
| - FROM_HERE,
|
| - base::Bind(&ProcTask::RetryIfNotComplete, this),
|
| - params_.unresponsive_delay);
|
| - }
|
| - }
|
| -
|
| - // WARNING: This code runs inside a worker pool. The shutdown code cannot
|
| - // wait for it to finish, so we must be very careful here about using other
|
| - // objects (like MessageLoops, Singletons, etc). During shutdown these objects
|
| - // may no longer exist. Multiple DoLookups() could be running in parallel, so
|
| - // any state inside of |this| must not mutate .
|
| - void DoLookup(const base::TimeTicks& start_time,
|
| - const uint32 attempt_number) {
|
| - AddressList results;
|
| - int os_error = 0;
|
| - // Running on the worker thread
|
| - int error = params_.resolver_proc->Resolve(key_.hostname,
|
| - key_.address_family,
|
| - key_.host_resolver_flags,
|
| - &results,
|
| - &os_error);
|
| -
|
| - origin_loop_->PostTask(
|
| - FROM_HERE,
|
| - base::Bind(&ProcTask::OnLookupComplete, this, results, start_time,
|
| - attempt_number, error, os_error));
|
| - }
|
| -
|
| - // Makes next attempt if DoLookup() has not finished (runs on origin thread).
|
| - void RetryIfNotComplete() {
|
| - DCHECK(origin_loop_->BelongsToCurrentThread());
|
| -
|
| - if (was_completed() || was_canceled())
|
| - return;
|
| -
|
| - params_.unresponsive_delay *= params_.retry_factor;
|
| - StartLookupAttempt();
|
| - }
|
| -
|
| - // Callback for when DoLookup() completes (runs on origin thread).
|
| - void OnLookupComplete(const AddressList& results,
|
| - const base::TimeTicks& start_time,
|
| - const uint32 attempt_number,
|
| - int error,
|
| - const int os_error) {
|
| - // TODO(vadimt): Remove ScopedTracker below once crbug.com/436634 is fixed.
|
| - tracked_objects::ScopedTracker tracking_profile1(
|
| - FROM_HERE_WITH_EXPLICIT_FUNCTION(
|
| - "436634 HostResolverImpl::ProcTask::OnLookupComplete1"));
|
| -
|
| - DCHECK(origin_loop_->BelongsToCurrentThread());
|
| - // If results are empty, we should return an error.
|
| - bool empty_list_on_ok = (error == OK && results.empty());
|
| - UMA_HISTOGRAM_BOOLEAN("DNS.EmptyAddressListAndNoError", empty_list_on_ok);
|
| - if (empty_list_on_ok)
|
| - error = ERR_NAME_NOT_RESOLVED;
|
| -
|
| - bool was_retry_attempt = attempt_number > 1;
|
| -
|
| - // Ideally the following code would be part of host_resolver_proc.cc,
|
| - // however it isn't safe to call NetworkChangeNotifier from worker threads.
|
| - // So we do it here on the IO thread instead.
|
| - if (error != OK && NetworkChangeNotifier::IsOffline())
|
| - error = ERR_INTERNET_DISCONNECTED;
|
| -
|
| - // If this is the first attempt that is finishing later, then record data
|
| - // for the first attempt. Won't contaminate with retry attempt's data.
|
| - if (!was_retry_attempt)
|
| - RecordPerformanceHistograms(start_time, error, os_error);
|
| -
|
| - RecordAttemptHistograms(start_time, attempt_number, error, os_error);
|
| -
|
| - if (was_canceled())
|
| - return;
|
| -
|
| - NetLog::ParametersCallback net_log_callback;
|
| - if (error != OK) {
|
| - net_log_callback = base::Bind(&NetLogProcTaskFailedCallback,
|
| - attempt_number,
|
| - error,
|
| - os_error);
|
| - } else {
|
| - net_log_callback = NetLog::IntegerCallback("attempt_number",
|
| - attempt_number);
|
| - }
|
| - net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_ATTEMPT_FINISHED,
|
| - net_log_callback);
|
| -
|
| - if (was_completed())
|
| - return;
|
| -
|
| - // Copy the results from the first worker thread that resolves the host.
|
| - results_ = results;
|
| - completed_attempt_number_ = attempt_number;
|
| - completed_attempt_error_ = error;
|
| -
|
| - if (was_retry_attempt) {
|
| - // If retry attempt finishes before 1st attempt, then get stats on how
|
| - // much time is saved by having spawned an extra attempt.
|
| - retry_attempt_finished_time_ = base::TimeTicks::Now();
|
| - }
|
| -
|
| - if (error != OK) {
|
| - net_log_callback = base::Bind(&NetLogProcTaskFailedCallback,
|
| - 0, error, os_error);
|
| - } else {
|
| - net_log_callback = results_.CreateNetLogCallback();
|
| - }
|
| - net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK,
|
| - net_log_callback);
|
| -
|
| - // TODO(vadimt): Remove ScopedTracker below once crbug.com/436634 is fixed.
|
| - tracked_objects::ScopedTracker tracking_profile2(
|
| - FROM_HERE_WITH_EXPLICIT_FUNCTION(
|
| - "436634 HostResolverImpl::ProcTask::OnLookupComplete2"));
|
| -
|
| - callback_.Run(error, results_);
|
| - }
|
| -
|
| - void RecordPerformanceHistograms(const base::TimeTicks& start_time,
|
| - const int error,
|
| - const int os_error) const {
|
| - DCHECK(origin_loop_->BelongsToCurrentThread());
|
| - enum Category { // Used in UMA_HISTOGRAM_ENUMERATION.
|
| - RESOLVE_SUCCESS,
|
| - RESOLVE_FAIL,
|
| - RESOLVE_SPECULATIVE_SUCCESS,
|
| - RESOLVE_SPECULATIVE_FAIL,
|
| - RESOLVE_MAX, // Bounding value.
|
| - };
|
| - int category = RESOLVE_MAX; // Illegal value for later DCHECK only.
|
| -
|
| - base::TimeDelta duration = base::TimeTicks::Now() - start_time;
|
| - if (error == OK) {
|
| - if (had_non_speculative_request_) {
|
| - category = RESOLVE_SUCCESS;
|
| - DNS_HISTOGRAM("DNS.ResolveSuccess", duration);
|
| - } else {
|
| - category = RESOLVE_SPECULATIVE_SUCCESS;
|
| - DNS_HISTOGRAM("DNS.ResolveSpeculativeSuccess", duration);
|
| - }
|
| -
|
| - // Log DNS lookups based on |address_family|. This will help us determine
|
| - // if IPv4 or IPv4/6 lookups are faster or slower.
|
| - switch(key_.address_family) {
|
| - case ADDRESS_FAMILY_IPV4:
|
| - DNS_HISTOGRAM("DNS.ResolveSuccess_FAMILY_IPV4", duration);
|
| - break;
|
| - case ADDRESS_FAMILY_IPV6:
|
| - DNS_HISTOGRAM("DNS.ResolveSuccess_FAMILY_IPV6", duration);
|
| - break;
|
| - case ADDRESS_FAMILY_UNSPECIFIED:
|
| - DNS_HISTOGRAM("DNS.ResolveSuccess_FAMILY_UNSPEC", duration);
|
| - break;
|
| - }
|
| - } else {
|
| - if (had_non_speculative_request_) {
|
| - category = RESOLVE_FAIL;
|
| - DNS_HISTOGRAM("DNS.ResolveFail", duration);
|
| - } else {
|
| - category = RESOLVE_SPECULATIVE_FAIL;
|
| - DNS_HISTOGRAM("DNS.ResolveSpeculativeFail", duration);
|
| - }
|
| - // Log DNS lookups based on |address_family|. This will help us determine
|
| - // if IPv4 or IPv4/6 lookups are faster or slower.
|
| - switch(key_.address_family) {
|
| - case ADDRESS_FAMILY_IPV4:
|
| - DNS_HISTOGRAM("DNS.ResolveFail_FAMILY_IPV4", duration);
|
| - break;
|
| - case ADDRESS_FAMILY_IPV6:
|
| - DNS_HISTOGRAM("DNS.ResolveFail_FAMILY_IPV6", duration);
|
| - break;
|
| - case ADDRESS_FAMILY_UNSPECIFIED:
|
| - DNS_HISTOGRAM("DNS.ResolveFail_FAMILY_UNSPEC", duration);
|
| - break;
|
| - }
|
| - UMA_HISTOGRAM_CUSTOM_ENUMERATION(kOSErrorsForGetAddrinfoHistogramName,
|
| - std::abs(os_error),
|
| - GetAllGetAddrinfoOSErrors());
|
| - }
|
| - DCHECK_LT(category, static_cast<int>(RESOLVE_MAX)); // Be sure it was set.
|
| -
|
| - UMA_HISTOGRAM_ENUMERATION("DNS.ResolveCategory", category, RESOLVE_MAX);
|
| - }
|
| -
|
| - void RecordAttemptHistograms(const base::TimeTicks& start_time,
|
| - const uint32 attempt_number,
|
| - const int error,
|
| - const int os_error) const {
|
| - DCHECK(origin_loop_->BelongsToCurrentThread());
|
| - bool first_attempt_to_complete =
|
| - completed_attempt_number_ == attempt_number;
|
| - bool is_first_attempt = (attempt_number == 1);
|
| -
|
| - if (first_attempt_to_complete) {
|
| - // If this was first attempt to complete, then record the resolution
|
| - // status of the attempt.
|
| - if (completed_attempt_error_ == OK) {
|
| - UMA_HISTOGRAM_ENUMERATION(
|
| - "DNS.AttemptFirstSuccess", attempt_number, 100);
|
| - } else {
|
| - UMA_HISTOGRAM_ENUMERATION(
|
| - "DNS.AttemptFirstFailure", attempt_number, 100);
|
| - }
|
| - }
|
| -
|
| - if (error == OK)
|
| - UMA_HISTOGRAM_ENUMERATION("DNS.AttemptSuccess", attempt_number, 100);
|
| - else
|
| - UMA_HISTOGRAM_ENUMERATION("DNS.AttemptFailure", attempt_number, 100);
|
| -
|
| - // If first attempt didn't finish before retry attempt, then calculate stats
|
| - // on how much time is saved by having spawned an extra attempt.
|
| - if (!first_attempt_to_complete && is_first_attempt && !was_canceled()) {
|
| - DNS_HISTOGRAM("DNS.AttemptTimeSavedByRetry",
|
| - base::TimeTicks::Now() - retry_attempt_finished_time_);
|
| - }
|
| -
|
| - if (was_canceled() || !first_attempt_to_complete) {
|
| - // Count those attempts which completed after the job was already canceled
|
| - // OR after the job was already completed by an earlier attempt (so in
|
| - // effect).
|
| - UMA_HISTOGRAM_ENUMERATION("DNS.AttemptDiscarded", attempt_number, 100);
|
| -
|
| - // Record if job is canceled.
|
| - if (was_canceled())
|
| - UMA_HISTOGRAM_ENUMERATION("DNS.AttemptCancelled", attempt_number, 100);
|
| - }
|
| -
|
| - base::TimeDelta duration = base::TimeTicks::Now() - start_time;
|
| - if (error == OK)
|
| - DNS_HISTOGRAM("DNS.AttemptSuccessDuration", duration);
|
| - else
|
| - DNS_HISTOGRAM("DNS.AttemptFailDuration", duration);
|
| - }
|
| -
|
| - // Set on the origin thread, read on the worker thread.
|
| - Key key_;
|
| -
|
| - // 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
|
| - // ResolveAddrInfo, but that's OK... we'll use it anyways, and the owning
|
| - // reference ensures that it remains valid until we are done.
|
| - ProcTaskParams params_;
|
| -
|
| - // The listener to the results of this ProcTask.
|
| - Callback callback_;
|
| -
|
| - // Used to post ourselves onto the origin thread.
|
| - scoped_refptr<base::MessageLoopProxy> origin_loop_;
|
| -
|
| - // Keeps track of the number of attempts we have made so far to resolve the
|
| - // host. Whenever we start an attempt to resolve the host, we increase this
|
| - // number.
|
| - uint32 attempt_number_;
|
| -
|
| - // The index of the attempt which finished first (or 0 if the job is still in
|
| - // progress).
|
| - uint32 completed_attempt_number_;
|
| -
|
| - // The result (a net error code) from the first attempt to complete.
|
| - int completed_attempt_error_;
|
| -
|
| - // The time when retry attempt was finished.
|
| - base::TimeTicks retry_attempt_finished_time_;
|
| -
|
| - // True if a non-speculative request was ever attached to this job
|
| - // (regardless of whether or not it was later canceled.
|
| - // This boolean is used for histogramming the duration of jobs used to
|
| - // service non-speculative requests.
|
| - bool had_non_speculative_request_;
|
| -
|
| - AddressList results_;
|
| -
|
| - BoundNetLog net_log_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(ProcTask);
|
| -};
|
| -
|
| -//-----------------------------------------------------------------------------
|
| -
|
| -// Wraps a call to HaveOnlyLoopbackAddresses to be executed on the WorkerPool as
|
| -// it takes 40-100ms and should not block initialization.
|
| -class HostResolverImpl::LoopbackProbeJob {
|
| - public:
|
| - explicit LoopbackProbeJob(const base::WeakPtr<HostResolverImpl>& resolver)
|
| - : resolver_(resolver),
|
| - result_(false) {
|
| - DCHECK(resolver.get());
|
| - const bool kIsSlow = true;
|
| - base::WorkerPool::PostTaskAndReply(
|
| - FROM_HERE,
|
| - base::Bind(&LoopbackProbeJob::DoProbe, base::Unretained(this)),
|
| - base::Bind(&LoopbackProbeJob::OnProbeComplete, base::Owned(this)),
|
| - kIsSlow);
|
| - }
|
| -
|
| - virtual ~LoopbackProbeJob() {}
|
| -
|
| - private:
|
| - // Runs on worker thread.
|
| - void DoProbe() {
|
| - result_ = HaveOnlyLoopbackAddresses();
|
| - }
|
| -
|
| - void OnProbeComplete() {
|
| - if (!resolver_.get())
|
| - return;
|
| - resolver_->SetHaveOnlyLoopbackAddresses(result_);
|
| - }
|
| -
|
| - // Used/set only on origin thread.
|
| - base::WeakPtr<HostResolverImpl> resolver_;
|
| -
|
| - bool result_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(LoopbackProbeJob);
|
| -};
|
| -
|
| -//-----------------------------------------------------------------------------
|
| -
|
| -// Resolves the hostname using DnsTransaction.
|
| -// TODO(szym): This could be moved to separate source file as well.
|
| -class HostResolverImpl::DnsTask : public base::SupportsWeakPtr<DnsTask> {
|
| - public:
|
| - class Delegate {
|
| - public:
|
| - virtual void OnDnsTaskComplete(base::TimeTicks start_time,
|
| - int net_error,
|
| - const AddressList& addr_list,
|
| - base::TimeDelta ttl) = 0;
|
| -
|
| - // Called when the first of two jobs succeeds. If the first completed
|
| - // transaction fails, this is not called. Also not called when the DnsTask
|
| - // only needs to run one transaction.
|
| - virtual void OnFirstDnsTransactionComplete() = 0;
|
| -
|
| - protected:
|
| - Delegate() {}
|
| - virtual ~Delegate() {}
|
| - };
|
| -
|
| - DnsTask(DnsClient* client,
|
| - const Key& key,
|
| - Delegate* delegate,
|
| - const BoundNetLog& job_net_log)
|
| - : client_(client),
|
| - key_(key),
|
| - delegate_(delegate),
|
| - net_log_(job_net_log),
|
| - num_completed_transactions_(0),
|
| - task_start_time_(base::TimeTicks::Now()) {
|
| - DCHECK(client);
|
| - DCHECK(delegate_);
|
| - }
|
| -
|
| - bool needs_two_transactions() const {
|
| - return key_.address_family == ADDRESS_FAMILY_UNSPECIFIED;
|
| - }
|
| -
|
| - bool needs_another_transaction() const {
|
| - return needs_two_transactions() && !transaction_aaaa_;
|
| - }
|
| -
|
| - void StartFirstTransaction() {
|
| - DCHECK_EQ(0u, num_completed_transactions_);
|
| - net_log_.BeginEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK);
|
| - if (key_.address_family == ADDRESS_FAMILY_IPV6) {
|
| - StartAAAA();
|
| - } else {
|
| - StartA();
|
| - }
|
| - }
|
| -
|
| - void StartSecondTransaction() {
|
| - DCHECK(needs_two_transactions());
|
| - StartAAAA();
|
| - }
|
| -
|
| - private:
|
| - void StartA() {
|
| - DCHECK(!transaction_a_);
|
| - DCHECK_NE(ADDRESS_FAMILY_IPV6, key_.address_family);
|
| - transaction_a_ = CreateTransaction(ADDRESS_FAMILY_IPV4);
|
| - transaction_a_->Start();
|
| - }
|
| -
|
| - void StartAAAA() {
|
| - DCHECK(!transaction_aaaa_);
|
| - DCHECK_NE(ADDRESS_FAMILY_IPV4, key_.address_family);
|
| - transaction_aaaa_ = CreateTransaction(ADDRESS_FAMILY_IPV6);
|
| - transaction_aaaa_->Start();
|
| - }
|
| -
|
| - scoped_ptr<DnsTransaction> CreateTransaction(AddressFamily family) {
|
| - DCHECK_NE(ADDRESS_FAMILY_UNSPECIFIED, family);
|
| - return client_->GetTransactionFactory()->CreateTransaction(
|
| - key_.hostname,
|
| - family == ADDRESS_FAMILY_IPV6 ? dns_protocol::kTypeAAAA :
|
| - dns_protocol::kTypeA,
|
| - base::Bind(&DnsTask::OnTransactionComplete, base::Unretained(this),
|
| - base::TimeTicks::Now()),
|
| - net_log_);
|
| - }
|
| -
|
| - void OnTransactionComplete(const base::TimeTicks& start_time,
|
| - DnsTransaction* transaction,
|
| - int net_error,
|
| - const DnsResponse* response) {
|
| - DCHECK(transaction);
|
| - base::TimeDelta duration = base::TimeTicks::Now() - start_time;
|
| - if (net_error != OK) {
|
| - DNS_HISTOGRAM("AsyncDNS.TransactionFailure", duration);
|
| - OnFailure(net_error, DnsResponse::DNS_PARSE_OK);
|
| - return;
|
| - }
|
| -
|
| - DNS_HISTOGRAM("AsyncDNS.TransactionSuccess", duration);
|
| - switch (transaction->GetType()) {
|
| - case dns_protocol::kTypeA:
|
| - DNS_HISTOGRAM("AsyncDNS.TransactionSuccess_A", duration);
|
| - break;
|
| - case dns_protocol::kTypeAAAA:
|
| - DNS_HISTOGRAM("AsyncDNS.TransactionSuccess_AAAA", duration);
|
| - break;
|
| - }
|
| -
|
| - AddressList addr_list;
|
| - base::TimeDelta ttl;
|
| - DnsResponse::Result result = response->ParseToAddressList(&addr_list, &ttl);
|
| - UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ParseToAddressList",
|
| - result,
|
| - DnsResponse::DNS_PARSE_RESULT_MAX);
|
| - if (result != DnsResponse::DNS_PARSE_OK) {
|
| - // Fail even if the other query succeeds.
|
| - OnFailure(ERR_DNS_MALFORMED_RESPONSE, result);
|
| - return;
|
| - }
|
| -
|
| - ++num_completed_transactions_;
|
| - if (num_completed_transactions_ == 1) {
|
| - ttl_ = ttl;
|
| - } else {
|
| - ttl_ = std::min(ttl_, ttl);
|
| - }
|
| -
|
| - if (transaction->GetType() == dns_protocol::kTypeA) {
|
| - DCHECK_EQ(transaction_a_.get(), transaction);
|
| - // Place IPv4 addresses after IPv6.
|
| - addr_list_.insert(addr_list_.end(), addr_list.begin(), addr_list.end());
|
| - } else {
|
| - DCHECK_EQ(transaction_aaaa_.get(), transaction);
|
| - // Place IPv6 addresses before IPv4.
|
| - addr_list_.insert(addr_list_.begin(), addr_list.begin(), addr_list.end());
|
| - }
|
| -
|
| - if (needs_two_transactions() && num_completed_transactions_ == 1) {
|
| - // No need to repeat the suffix search.
|
| - key_.hostname = transaction->GetHostname();
|
| - delegate_->OnFirstDnsTransactionComplete();
|
| - return;
|
| - }
|
| -
|
| - if (addr_list_.empty()) {
|
| - // TODO(szym): Don't fallback to ProcTask in this case.
|
| - OnFailure(ERR_NAME_NOT_RESOLVED, DnsResponse::DNS_PARSE_OK);
|
| - return;
|
| - }
|
| -
|
| - // If there are multiple addresses, and at least one is IPv6, need to sort
|
| - // them. Note that IPv6 addresses are always put before IPv4 ones, so it's
|
| - // sufficient to just check the family of the first address.
|
| - if (addr_list_.size() > 1 &&
|
| - addr_list_[0].GetFamily() == ADDRESS_FAMILY_IPV6) {
|
| - // Sort addresses if needed. Sort could complete synchronously.
|
| - client_->GetAddressSorter()->Sort(
|
| - addr_list_,
|
| - base::Bind(&DnsTask::OnSortComplete,
|
| - AsWeakPtr(),
|
| - base::TimeTicks::Now()));
|
| - } else {
|
| - OnSuccess(addr_list_);
|
| - }
|
| - }
|
| -
|
| - void OnSortComplete(base::TimeTicks start_time,
|
| - bool success,
|
| - const AddressList& addr_list) {
|
| - if (!success) {
|
| - DNS_HISTOGRAM("AsyncDNS.SortFailure",
|
| - base::TimeTicks::Now() - start_time);
|
| - OnFailure(ERR_DNS_SORT_ERROR, DnsResponse::DNS_PARSE_OK);
|
| - return;
|
| - }
|
| -
|
| - DNS_HISTOGRAM("AsyncDNS.SortSuccess",
|
| - base::TimeTicks::Now() - start_time);
|
| -
|
| - // AddressSorter prunes unusable destinations.
|
| - if (addr_list.empty()) {
|
| - LOG(WARNING) << "Address list empty after RFC3484 sort";
|
| - OnFailure(ERR_NAME_NOT_RESOLVED, DnsResponse::DNS_PARSE_OK);
|
| - return;
|
| - }
|
| -
|
| - OnSuccess(addr_list);
|
| - }
|
| -
|
| - void OnFailure(int net_error, DnsResponse::Result result) {
|
| - DCHECK_NE(OK, net_error);
|
| - net_log_.EndEvent(
|
| - NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK,
|
| - base::Bind(&NetLogDnsTaskFailedCallback, net_error, result));
|
| - delegate_->OnDnsTaskComplete(task_start_time_, net_error, AddressList(),
|
| - base::TimeDelta());
|
| - }
|
| -
|
| - void OnSuccess(const AddressList& addr_list) {
|
| - net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK,
|
| - addr_list.CreateNetLogCallback());
|
| - delegate_->OnDnsTaskComplete(task_start_time_, OK, addr_list, ttl_);
|
| - }
|
| -
|
| - DnsClient* client_;
|
| - Key key_;
|
| -
|
| - // The listener to the results of this DnsTask.
|
| - Delegate* delegate_;
|
| - const BoundNetLog net_log_;
|
| -
|
| - scoped_ptr<DnsTransaction> transaction_a_;
|
| - scoped_ptr<DnsTransaction> transaction_aaaa_;
|
| -
|
| - unsigned num_completed_transactions_;
|
| -
|
| - // These are updated as each transaction completes.
|
| - base::TimeDelta ttl_;
|
| - // IPv6 addresses must appear first in the list.
|
| - AddressList addr_list_;
|
| -
|
| - base::TimeTicks task_start_time_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(DnsTask);
|
| -};
|
| -
|
| -//-----------------------------------------------------------------------------
|
| -
|
| -// Aggregates all Requests for the same Key. Dispatched via PriorityDispatch.
|
| -class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
|
| - public HostResolverImpl::DnsTask::Delegate {
|
| - public:
|
| - // Creates new job for |key| where |request_net_log| is bound to the
|
| - // request that spawned it.
|
| - Job(const base::WeakPtr<HostResolverImpl>& resolver,
|
| - const Key& key,
|
| - RequestPriority priority,
|
| - const BoundNetLog& source_net_log)
|
| - : resolver_(resolver),
|
| - key_(key),
|
| - priority_tracker_(priority),
|
| - had_non_speculative_request_(false),
|
| - had_dns_config_(false),
|
| - num_occupied_job_slots_(0),
|
| - dns_task_error_(OK),
|
| - creation_time_(base::TimeTicks::Now()),
|
| - priority_change_time_(creation_time_),
|
| - net_log_(BoundNetLog::Make(source_net_log.net_log(),
|
| - NetLog::SOURCE_HOST_RESOLVER_IMPL_JOB)) {
|
| - source_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CREATE_JOB);
|
| -
|
| - net_log_.BeginEvent(
|
| - NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
|
| - base::Bind(&NetLogJobCreationCallback,
|
| - source_net_log.source(),
|
| - &key_.hostname));
|
| - }
|
| -
|
| - ~Job() override {
|
| - if (is_running()) {
|
| - // |resolver_| was destroyed with this Job still in flight.
|
| - // Clean-up, record in the log, but don't run any callbacks.
|
| - if (is_proc_running()) {
|
| - proc_task_->Cancel();
|
| - proc_task_ = NULL;
|
| - }
|
| - // Clean up now for nice NetLog.
|
| - KillDnsTask();
|
| - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
|
| - ERR_ABORTED);
|
| - } else if (is_queued()) {
|
| - // |resolver_| was destroyed without running this Job.
|
| - // TODO(szym): is there any benefit in having this distinction?
|
| - net_log_.AddEvent(NetLog::TYPE_CANCELLED);
|
| - net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB);
|
| - }
|
| - // else CompleteRequests logged EndEvent.
|
| -
|
| - // Log any remaining Requests as cancelled.
|
| - for (RequestsList::const_iterator it = requests_.begin();
|
| - it != requests_.end(); ++it) {
|
| - Request* req = *it;
|
| - if (req->was_canceled())
|
| - continue;
|
| - DCHECK_EQ(this, req->job());
|
| - LogCancelRequest(req->source_net_log(), req->info());
|
| - }
|
| - }
|
| -
|
| - // Add this job to the dispatcher. If "at_head" is true, adds at the front
|
| - // of the queue.
|
| - void Schedule(bool at_head) {
|
| - DCHECK(!is_queued());
|
| - PrioritizedDispatcher::Handle handle;
|
| - if (!at_head) {
|
| - handle = resolver_->dispatcher_->Add(this, priority());
|
| - } else {
|
| - handle = resolver_->dispatcher_->AddAtHead(this, priority());
|
| - }
|
| - // The dispatcher could have started |this| in the above call to Add, which
|
| - // could have called Schedule again. In that case |handle| will be null,
|
| - // but |handle_| may have been set by the other nested call to Schedule.
|
| - if (!handle.is_null()) {
|
| - DCHECK(handle_.is_null());
|
| - handle_ = handle;
|
| - }
|
| - }
|
| -
|
| - void AddRequest(scoped_ptr<Request> req) {
|
| - DCHECK_EQ(key_.hostname, req->info().hostname());
|
| -
|
| - req->set_job(this);
|
| - priority_tracker_.Add(req->priority());
|
| -
|
| - req->source_net_log().AddEvent(
|
| - NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_ATTACH,
|
| - net_log_.source().ToEventParametersCallback());
|
| -
|
| - net_log_.AddEvent(
|
| - NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_ATTACH,
|
| - base::Bind(&NetLogJobAttachCallback,
|
| - req->source_net_log().source(),
|
| - priority()));
|
| -
|
| - // TODO(szym): Check if this is still needed.
|
| - if (!req->info().is_speculative()) {
|
| - had_non_speculative_request_ = true;
|
| - if (proc_task_.get())
|
| - proc_task_->set_had_non_speculative_request();
|
| - }
|
| -
|
| - requests_.push_back(req.release());
|
| -
|
| - UpdatePriority();
|
| - }
|
| -
|
| - // Marks |req| as cancelled. If it was the last active Request, also finishes
|
| - // this Job, marking it as cancelled, and deletes it.
|
| - void CancelRequest(Request* req) {
|
| - DCHECK_EQ(key_.hostname, req->info().hostname());
|
| - DCHECK(!req->was_canceled());
|
| -
|
| - // Don't remove it from |requests_| just mark it canceled.
|
| - req->MarkAsCanceled();
|
| - LogCancelRequest(req->source_net_log(), req->info());
|
| -
|
| - priority_tracker_.Remove(req->priority());
|
| - net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_DETACH,
|
| - base::Bind(&NetLogJobAttachCallback,
|
| - req->source_net_log().source(),
|
| - priority()));
|
| -
|
| - if (num_active_requests() > 0) {
|
| - UpdatePriority();
|
| - } else {
|
| - // If we were called from a Request's callback within CompleteRequests,
|
| - // that Request could not have been cancelled, so num_active_requests()
|
| - // could not be 0. Therefore, we are not in CompleteRequests().
|
| - CompleteRequestsWithError(OK /* cancelled */);
|
| - }
|
| - }
|
| -
|
| - // Called from AbortAllInProgressJobs. Completes all requests and destroys
|
| - // the job. This currently assumes the abort is due to a network change.
|
| - void Abort() {
|
| - DCHECK(is_running());
|
| - CompleteRequestsWithError(ERR_NETWORK_CHANGED);
|
| - }
|
| -
|
| - // If DnsTask present, abort it and fall back to ProcTask.
|
| - void AbortDnsTask() {
|
| - if (dns_task_) {
|
| - KillDnsTask();
|
| - dns_task_error_ = OK;
|
| - StartProcTask();
|
| - }
|
| - }
|
| -
|
| - // Called by HostResolverImpl when this job is evicted due to queue overflow.
|
| - // Completes all requests and destroys the job.
|
| - void OnEvicted() {
|
| - DCHECK(!is_running());
|
| - DCHECK(is_queued());
|
| - handle_.Reset();
|
| -
|
| - net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_EVICTED);
|
| -
|
| - // This signals to CompleteRequests that this job never ran.
|
| - CompleteRequestsWithError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);
|
| - }
|
| -
|
| - // Attempts to serve the job from HOSTS. Returns true if succeeded and
|
| - // this Job was destroyed.
|
| - bool ServeFromHosts() {
|
| - DCHECK_GT(num_active_requests(), 0u);
|
| - AddressList addr_list;
|
| - if (resolver_->ServeFromHosts(key(),
|
| - requests_.front()->info(),
|
| - &addr_list)) {
|
| - // This will destroy the Job.
|
| - CompleteRequests(
|
| - HostCache::Entry(OK, MakeAddressListForRequest(addr_list)),
|
| - base::TimeDelta());
|
| - return true;
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - const Key key() const {
|
| - return key_;
|
| - }
|
| -
|
| - bool is_queued() const {
|
| - return !handle_.is_null();
|
| - }
|
| -
|
| - bool is_running() const {
|
| - return is_dns_running() || is_proc_running();
|
| - }
|
| -
|
| - private:
|
| - void KillDnsTask() {
|
| - if (dns_task_) {
|
| - ReduceToOneJobSlot();
|
| - dns_task_.reset();
|
| - }
|
| - }
|
| -
|
| - // Reduce the number of job slots occupied and queued in the dispatcher
|
| - // to one. If the second Job slot is queued in the dispatcher, cancels the
|
| - // queued job. Otherwise, the second Job has been started by the
|
| - // PrioritizedDispatcher, so signals it is complete.
|
| - void ReduceToOneJobSlot() {
|
| - DCHECK_GE(num_occupied_job_slots_, 1u);
|
| - if (is_queued()) {
|
| - resolver_->dispatcher_->Cancel(handle_);
|
| - handle_.Reset();
|
| - } else if (num_occupied_job_slots_ > 1) {
|
| - resolver_->dispatcher_->OnJobFinished();
|
| - --num_occupied_job_slots_;
|
| - }
|
| - DCHECK_EQ(1u, num_occupied_job_slots_);
|
| - }
|
| -
|
| - void UpdatePriority() {
|
| - if (is_queued()) {
|
| - if (priority() != static_cast<RequestPriority>(handle_.priority()))
|
| - priority_change_time_ = base::TimeTicks::Now();
|
| - handle_ = resolver_->dispatcher_->ChangePriority(handle_, priority());
|
| - }
|
| - }
|
| -
|
| - AddressList MakeAddressListForRequest(const AddressList& list) const {
|
| - if (requests_.empty())
|
| - return list;
|
| - return AddressList::CopyWithPort(list, requests_.front()->info().port());
|
| - }
|
| -
|
| - // PriorityDispatch::Job:
|
| - void Start() override {
|
| - DCHECK_LE(num_occupied_job_slots_, 1u);
|
| -
|
| - handle_.Reset();
|
| - ++num_occupied_job_slots_;
|
| -
|
| - if (num_occupied_job_slots_ == 2) {
|
| - StartSecondDnsTransaction();
|
| - return;
|
| - }
|
| -
|
| - DCHECK(!is_running());
|
| -
|
| - net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_STARTED);
|
| -
|
| - had_dns_config_ = resolver_->HaveDnsConfig();
|
| -
|
| - base::TimeTicks now = base::TimeTicks::Now();
|
| - base::TimeDelta queue_time = now - creation_time_;
|
| - base::TimeDelta queue_time_after_change = now - priority_change_time_;
|
| -
|
| - if (had_dns_config_) {
|
| - DNS_HISTOGRAM_BY_PRIORITY("AsyncDNS.JobQueueTime", priority(),
|
| - queue_time);
|
| - DNS_HISTOGRAM_BY_PRIORITY("AsyncDNS.JobQueueTimeAfterChange", priority(),
|
| - queue_time_after_change);
|
| - } else {
|
| - DNS_HISTOGRAM_BY_PRIORITY("DNS.JobQueueTime", priority(), queue_time);
|
| - DNS_HISTOGRAM_BY_PRIORITY("DNS.JobQueueTimeAfterChange", priority(),
|
| - queue_time_after_change);
|
| - }
|
| -
|
| - bool system_only =
|
| - (key_.host_resolver_flags & HOST_RESOLVER_SYSTEM_ONLY) != 0;
|
| -
|
| - // Caution: Job::Start must not complete synchronously.
|
| - if (!system_only && had_dns_config_ &&
|
| - !ResemblesMulticastDNSName(key_.hostname)) {
|
| - StartDnsTask();
|
| - } else {
|
| - StartProcTask();
|
| - }
|
| - }
|
| -
|
| - // TODO(szym): Since DnsTransaction does not consume threads, we can increase
|
| - // the limits on |dispatcher_|. But in order to keep the number of WorkerPool
|
| - // threads low, we will need to use an "inner" PrioritizedDispatcher with
|
| - // tighter limits.
|
| - void StartProcTask() {
|
| - DCHECK(!is_dns_running());
|
| - proc_task_ = new ProcTask(
|
| - key_,
|
| - resolver_->proc_params_,
|
| - base::Bind(&Job::OnProcTaskComplete, base::Unretained(this),
|
| - base::TimeTicks::Now()),
|
| - net_log_);
|
| -
|
| - if (had_non_speculative_request_)
|
| - proc_task_->set_had_non_speculative_request();
|
| - // Start() could be called from within Resolve(), hence it must NOT directly
|
| - // call OnProcTaskComplete, for example, on synchronous failure.
|
| - proc_task_->Start();
|
| - }
|
| -
|
| - // Called by ProcTask when it completes.
|
| - void OnProcTaskComplete(base::TimeTicks start_time,
|
| - int net_error,
|
| - const AddressList& addr_list) {
|
| - // TODO(vadimt): Remove ScopedTracker below once crbug.com/436634 is fixed.
|
| - tracked_objects::ScopedTracker tracking_profile(
|
| - FROM_HERE_WITH_EXPLICIT_FUNCTION(
|
| - "436634 HostResolverImpl::Job::OnProcTaskComplete"));
|
| -
|
| - DCHECK(is_proc_running());
|
| -
|
| - if (!resolver_->resolved_known_ipv6_hostname_ &&
|
| - net_error == OK &&
|
| - key_.address_family == ADDRESS_FAMILY_UNSPECIFIED) {
|
| - if (key_.hostname == "www.google.com") {
|
| - resolver_->resolved_known_ipv6_hostname_ = true;
|
| - bool got_ipv6_address = false;
|
| - for (size_t i = 0; i < addr_list.size(); ++i) {
|
| - if (addr_list[i].GetFamily() == ADDRESS_FAMILY_IPV6) {
|
| - got_ipv6_address = true;
|
| - break;
|
| - }
|
| - }
|
| - UMA_HISTOGRAM_BOOLEAN("Net.UnspecResolvedIPv6", got_ipv6_address);
|
| - }
|
| - }
|
| -
|
| - if (dns_task_error_ != OK) {
|
| - base::TimeDelta duration = base::TimeTicks::Now() - start_time;
|
| - if (net_error == OK) {
|
| - DNS_HISTOGRAM("AsyncDNS.FallbackSuccess", duration);
|
| - if ((dns_task_error_ == ERR_NAME_NOT_RESOLVED) &&
|
| - ResemblesNetBIOSName(key_.hostname)) {
|
| - UmaAsyncDnsResolveStatus(RESOLVE_STATUS_SUSPECT_NETBIOS);
|
| - } else {
|
| - UmaAsyncDnsResolveStatus(RESOLVE_STATUS_PROC_SUCCESS);
|
| - }
|
| - UMA_HISTOGRAM_CUSTOM_ENUMERATION("AsyncDNS.ResolveError",
|
| - std::abs(dns_task_error_),
|
| - GetAllErrorCodesForUma());
|
| - resolver_->OnDnsTaskResolve(dns_task_error_);
|
| - } else {
|
| - DNS_HISTOGRAM("AsyncDNS.FallbackFail", duration);
|
| - UmaAsyncDnsResolveStatus(RESOLVE_STATUS_FAIL);
|
| - }
|
| - }
|
| -
|
| - base::TimeDelta ttl =
|
| - base::TimeDelta::FromSeconds(kNegativeCacheEntryTTLSeconds);
|
| - if (net_error == OK)
|
| - ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
|
| -
|
| - // Don't store the |ttl| in cache since it's not obtained from the server.
|
| - CompleteRequests(
|
| - HostCache::Entry(net_error, MakeAddressListForRequest(addr_list)),
|
| - ttl);
|
| - }
|
| -
|
| - void StartDnsTask() {
|
| - DCHECK(resolver_->HaveDnsConfig());
|
| - dns_task_.reset(new DnsTask(resolver_->dns_client_.get(), key_, this,
|
| - net_log_));
|
| -
|
| - dns_task_->StartFirstTransaction();
|
| - // Schedule a second transaction, if needed.
|
| - if (dns_task_->needs_two_transactions())
|
| - Schedule(true);
|
| - }
|
| -
|
| - void StartSecondDnsTransaction() {
|
| - DCHECK(dns_task_->needs_two_transactions());
|
| - dns_task_->StartSecondTransaction();
|
| - }
|
| -
|
| - // Called if DnsTask fails. It is posted from StartDnsTask, so Job may be
|
| - // deleted before this callback. In this case dns_task is deleted as well,
|
| - // so we use it as indicator whether Job is still valid.
|
| - void OnDnsTaskFailure(const base::WeakPtr<DnsTask>& dns_task,
|
| - base::TimeDelta duration,
|
| - int net_error) {
|
| - DNS_HISTOGRAM("AsyncDNS.ResolveFail", duration);
|
| -
|
| - if (dns_task == NULL)
|
| - return;
|
| -
|
| - dns_task_error_ = net_error;
|
| -
|
| - // TODO(szym): Run ServeFromHosts now if nsswitch.conf says so.
|
| - // http://crbug.com/117655
|
| -
|
| - // TODO(szym): Some net errors indicate lack of connectivity. Starting
|
| - // ProcTask in that case is a waste of time.
|
| - if (resolver_->fallback_to_proctask_) {
|
| - KillDnsTask();
|
| - StartProcTask();
|
| - } else {
|
| - UmaAsyncDnsResolveStatus(RESOLVE_STATUS_FAIL);
|
| - CompleteRequestsWithError(net_error);
|
| - }
|
| - }
|
| -
|
| -
|
| - // HostResolverImpl::DnsTask::Delegate implementation:
|
| -
|
| - void OnDnsTaskComplete(base::TimeTicks start_time,
|
| - int net_error,
|
| - const AddressList& addr_list,
|
| - base::TimeDelta ttl) override {
|
| - DCHECK(is_dns_running());
|
| -
|
| - base::TimeDelta duration = base::TimeTicks::Now() - start_time;
|
| - if (net_error != OK) {
|
| - OnDnsTaskFailure(dns_task_->AsWeakPtr(), duration, net_error);
|
| - return;
|
| - }
|
| - DNS_HISTOGRAM("AsyncDNS.ResolveSuccess", duration);
|
| - // Log DNS lookups based on |address_family|.
|
| - switch(key_.address_family) {
|
| - case ADDRESS_FAMILY_IPV4:
|
| - DNS_HISTOGRAM("AsyncDNS.ResolveSuccess_FAMILY_IPV4", duration);
|
| - break;
|
| - case ADDRESS_FAMILY_IPV6:
|
| - DNS_HISTOGRAM("AsyncDNS.ResolveSuccess_FAMILY_IPV6", duration);
|
| - break;
|
| - case ADDRESS_FAMILY_UNSPECIFIED:
|
| - DNS_HISTOGRAM("AsyncDNS.ResolveSuccess_FAMILY_UNSPEC", duration);
|
| - break;
|
| - }
|
| -
|
| - UmaAsyncDnsResolveStatus(RESOLVE_STATUS_DNS_SUCCESS);
|
| - RecordTTL(ttl);
|
| -
|
| - resolver_->OnDnsTaskResolve(OK);
|
| -
|
| - base::TimeDelta bounded_ttl =
|
| - std::max(ttl, base::TimeDelta::FromSeconds(kMinimumTTLSeconds));
|
| -
|
| - CompleteRequests(
|
| - HostCache::Entry(net_error, MakeAddressListForRequest(addr_list), ttl),
|
| - bounded_ttl);
|
| - }
|
| -
|
| - void OnFirstDnsTransactionComplete() override {
|
| - DCHECK(dns_task_->needs_two_transactions());
|
| - DCHECK_EQ(dns_task_->needs_another_transaction(), is_queued());
|
| - // No longer need to occupy two dispatcher slots.
|
| - ReduceToOneJobSlot();
|
| -
|
| - // We already have a job slot at the dispatcher, so if the second
|
| - // transaction hasn't started, reuse it now instead of waiting in the queue
|
| - // for the second slot.
|
| - if (dns_task_->needs_another_transaction())
|
| - dns_task_->StartSecondTransaction();
|
| - }
|
| -
|
| - // Performs Job's last rites. Completes all Requests. Deletes this.
|
| - void CompleteRequests(const HostCache::Entry& entry,
|
| - base::TimeDelta ttl) {
|
| - // TODO(vadimt): Remove ScopedTracker below once crbug.com/436634 is fixed.
|
| - tracked_objects::ScopedTracker tracking_profile1(
|
| - FROM_HERE_WITH_EXPLICIT_FUNCTION(
|
| - "436634 HostResolverImpl::Job::CompleteRequests1"));
|
| -
|
| - CHECK(resolver_.get());
|
| -
|
| - // This job must be removed from resolver's |jobs_| now to make room for a
|
| - // new job with the same key in case one of the OnComplete callbacks decides
|
| - // to spawn one. Consequently, the job deletes itself when CompleteRequests
|
| - // is done.
|
| - scoped_ptr<Job> self_deleter(this);
|
| -
|
| - resolver_->RemoveJob(this);
|
| -
|
| - if (is_running()) {
|
| - if (is_proc_running()) {
|
| - DCHECK(!is_queued());
|
| - proc_task_->Cancel();
|
| - proc_task_ = NULL;
|
| - }
|
| - KillDnsTask();
|
| -
|
| - // Signal dispatcher that a slot has opened.
|
| - resolver_->dispatcher_->OnJobFinished();
|
| - } else if (is_queued()) {
|
| - resolver_->dispatcher_->Cancel(handle_);
|
| - handle_.Reset();
|
| - }
|
| -
|
| - if (num_active_requests() == 0) {
|
| - net_log_.AddEvent(NetLog::TYPE_CANCELLED);
|
| - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
|
| - OK);
|
| - return;
|
| - }
|
| -
|
| - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
|
| - entry.error);
|
| -
|
| - DCHECK(!requests_.empty());
|
| -
|
| - if (entry.error == OK) {
|
| - // Record this histogram here, when we know the system has a valid DNS
|
| - // configuration.
|
| - UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HaveDnsConfig",
|
| - resolver_->received_dns_config_);
|
| - }
|
| -
|
| - bool did_complete = (entry.error != ERR_NETWORK_CHANGED) &&
|
| - (entry.error != ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);
|
| - if (did_complete)
|
| - resolver_->CacheResult(key_, entry, ttl);
|
| -
|
| - // TODO(vadimt): Remove ScopedTracker below once crbug.com/436634 is fixed.
|
| - tracked_objects::ScopedTracker tracking_profile2(
|
| - FROM_HERE_WITH_EXPLICIT_FUNCTION(
|
| - "436634 HostResolverImpl::Job::CompleteRequests2"));
|
| -
|
| - // Complete all of the requests that were attached to the job.
|
| - for (RequestsList::const_iterator it = requests_.begin();
|
| - it != requests_.end(); ++it) {
|
| - Request* req = *it;
|
| -
|
| - if (req->was_canceled())
|
| - continue;
|
| -
|
| - DCHECK_EQ(this, req->job());
|
| - // Update the net log and notify registered observers.
|
| - LogFinishRequest(req->source_net_log(), req->info(), entry.error);
|
| - if (did_complete) {
|
| - // Record effective total time from creation to completion.
|
| - RecordTotalTime(had_dns_config_, req->info().is_speculative(),
|
| - base::TimeTicks::Now() - req->request_time());
|
| - }
|
| - req->OnComplete(entry.error, entry.addrlist);
|
| -
|
| - // Check if the resolver was destroyed as a result of running the
|
| - // callback. If it was, we could continue, but we choose to bail.
|
| - if (!resolver_.get())
|
| - return;
|
| - }
|
| - }
|
| -
|
| - // Convenience wrapper for CompleteRequests in case of failure.
|
| - void CompleteRequestsWithError(int net_error) {
|
| - CompleteRequests(HostCache::Entry(net_error, AddressList()),
|
| - base::TimeDelta());
|
| - }
|
| -
|
| - RequestPriority priority() const {
|
| - return priority_tracker_.highest_priority();
|
| - }
|
| -
|
| - // Number of non-canceled requests in |requests_|.
|
| - size_t num_active_requests() const {
|
| - return priority_tracker_.total_count();
|
| - }
|
| -
|
| - bool is_dns_running() const {
|
| - return dns_task_.get() != NULL;
|
| - }
|
| -
|
| - bool is_proc_running() const {
|
| - return proc_task_.get() != NULL;
|
| - }
|
| -
|
| - base::WeakPtr<HostResolverImpl> resolver_;
|
| -
|
| - Key key_;
|
| -
|
| - // Tracks the highest priority across |requests_|.
|
| - PriorityTracker priority_tracker_;
|
| -
|
| - bool had_non_speculative_request_;
|
| -
|
| - // Distinguishes measurements taken while DnsClient was fully configured.
|
| - bool had_dns_config_;
|
| -
|
| - // Number of slots occupied by this Job in resolver's PrioritizedDispatcher.
|
| - unsigned num_occupied_job_slots_;
|
| -
|
| - // Result of DnsTask.
|
| - int dns_task_error_;
|
| -
|
| - const base::TimeTicks creation_time_;
|
| - base::TimeTicks priority_change_time_;
|
| -
|
| - BoundNetLog net_log_;
|
| -
|
| - // Resolves the host using a HostResolverProc.
|
| - scoped_refptr<ProcTask> proc_task_;
|
| -
|
| - // Resolves the host using a DnsTransaction.
|
| - scoped_ptr<DnsTask> dns_task_;
|
| -
|
| - // All Requests waiting for the result of this Job. Some can be canceled.
|
| - RequestsList requests_;
|
| -
|
| - // A handle used in |HostResolverImpl::dispatcher_|.
|
| - PrioritizedDispatcher::Handle handle_;
|
| -};
|
| -
|
| -//-----------------------------------------------------------------------------
|
| -
|
| -HostResolverImpl::ProcTaskParams::ProcTaskParams(
|
| - HostResolverProc* resolver_proc,
|
| - size_t max_retry_attempts)
|
| - : resolver_proc(resolver_proc),
|
| - max_retry_attempts(max_retry_attempts),
|
| - unresponsive_delay(base::TimeDelta::FromMilliseconds(6000)),
|
| - retry_factor(2) {
|
| - // Maximum of 4 retry attempts for host resolution.
|
| - static const size_t kDefaultMaxRetryAttempts = 4u;
|
| - if (max_retry_attempts == HostResolver::kDefaultRetryAttempts)
|
| - max_retry_attempts = kDefaultMaxRetryAttempts;
|
| -}
|
| -
|
| -HostResolverImpl::ProcTaskParams::~ProcTaskParams() {}
|
| -
|
| -HostResolverImpl::HostResolverImpl(const Options& options, NetLog* net_log)
|
| - : max_queued_jobs_(0),
|
| - proc_params_(NULL, options.max_retry_attempts),
|
| - net_log_(net_log),
|
| - default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
|
| - received_dns_config_(false),
|
| - num_dns_failures_(0),
|
| - probe_ipv6_support_(true),
|
| - use_local_ipv6_(false),
|
| - resolved_known_ipv6_hostname_(false),
|
| - additional_resolver_flags_(0),
|
| - fallback_to_proctask_(true),
|
| - weak_ptr_factory_(this),
|
| - probe_weak_ptr_factory_(this) {
|
| - if (options.enable_caching)
|
| - cache_ = HostCache::CreateDefaultCache();
|
| -
|
| - PrioritizedDispatcher::Limits job_limits = options.GetDispatcherLimits();
|
| - dispatcher_.reset(new PrioritizedDispatcher(job_limits));
|
| - max_queued_jobs_ = job_limits.total_jobs * 100u;
|
| -
|
| - DCHECK_GE(dispatcher_->num_priorities(), static_cast<size_t>(NUM_PRIORITIES));
|
| -
|
| -#if defined(OS_WIN)
|
| - EnsureWinsockInit();
|
| -#endif
|
| -#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
|
| - new LoopbackProbeJob(weak_ptr_factory_.GetWeakPtr());
|
| -#endif
|
| - NetworkChangeNotifier::AddIPAddressObserver(this);
|
| - NetworkChangeNotifier::AddDNSObserver(this);
|
| -#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) && \
|
| - !defined(OS_ANDROID)
|
| - EnsureDnsReloaderInit();
|
| -#endif
|
| -
|
| - {
|
| - DnsConfig dns_config;
|
| - NetworkChangeNotifier::GetDnsConfig(&dns_config);
|
| - received_dns_config_ = dns_config.IsValid();
|
| - // Conservatively assume local IPv6 is needed when DnsConfig is not valid.
|
| - use_local_ipv6_ = !dns_config.IsValid() || dns_config.use_local_ipv6;
|
| - }
|
| -
|
| - fallback_to_proctask_ = !ConfigureAsyncDnsNoFallbackFieldTrial();
|
| -}
|
| -
|
| -HostResolverImpl::~HostResolverImpl() {
|
| - // Prevent the dispatcher from starting new jobs.
|
| - dispatcher_->SetLimitsToZero();
|
| - // It's now safe for Jobs to call KillDsnTask on destruction, because
|
| - // OnJobComplete will not start any new jobs.
|
| - STLDeleteValues(&jobs_);
|
| -
|
| - NetworkChangeNotifier::RemoveIPAddressObserver(this);
|
| - NetworkChangeNotifier::RemoveDNSObserver(this);
|
| -}
|
| -
|
| -void HostResolverImpl::SetMaxQueuedJobs(size_t value) {
|
| - DCHECK_EQ(0u, dispatcher_->num_queued_jobs());
|
| - DCHECK_GT(value, 0u);
|
| - max_queued_jobs_ = value;
|
| -}
|
| -
|
| -int HostResolverImpl::Resolve(const RequestInfo& info,
|
| - RequestPriority priority,
|
| - AddressList* addresses,
|
| - const CompletionCallback& callback,
|
| - RequestHandle* out_req,
|
| - const BoundNetLog& source_net_log) {
|
| - DCHECK(addresses);
|
| - DCHECK(CalledOnValidThread());
|
| - DCHECK_EQ(false, callback.is_null());
|
| -
|
| - // Check that the caller supplied a valid hostname to resolve.
|
| - std::string labeled_hostname;
|
| - if (!DNSDomainFromDot(info.hostname(), &labeled_hostname))
|
| - return ERR_NAME_NOT_RESOLVED;
|
| -
|
| - LogStartRequest(source_net_log, info);
|
| -
|
| - // Build a key that identifies the request in the cache and in the
|
| - // outstanding jobs map.
|
| - Key key = GetEffectiveKeyForRequest(info, source_net_log);
|
| -
|
| - int rv = ResolveHelper(key, info, addresses, source_net_log);
|
| - if (rv != ERR_DNS_CACHE_MISS) {
|
| - LogFinishRequest(source_net_log, info, rv);
|
| - RecordTotalTime(HaveDnsConfig(), info.is_speculative(), base::TimeDelta());
|
| - return rv;
|
| - }
|
| -
|
| - // Next we need to attach our request to a "job". This job is responsible for
|
| - // calling "getaddrinfo(hostname)" on a worker thread.
|
| -
|
| - JobMap::iterator jobit = jobs_.find(key);
|
| - Job* job;
|
| - if (jobit == jobs_.end()) {
|
| - job =
|
| - new Job(weak_ptr_factory_.GetWeakPtr(), key, priority, source_net_log);
|
| - job->Schedule(false);
|
| -
|
| - // Check for queue overflow.
|
| - if (dispatcher_->num_queued_jobs() > max_queued_jobs_) {
|
| - Job* evicted = static_cast<Job*>(dispatcher_->EvictOldestLowest());
|
| - DCHECK(evicted);
|
| - evicted->OnEvicted(); // Deletes |evicted|.
|
| - if (evicted == job) {
|
| - rv = ERR_HOST_RESOLVER_QUEUE_TOO_LARGE;
|
| - LogFinishRequest(source_net_log, info, rv);
|
| - return rv;
|
| - }
|
| - }
|
| - jobs_.insert(jobit, std::make_pair(key, job));
|
| - } else {
|
| - job = jobit->second;
|
| - }
|
| -
|
| - // Can't complete synchronously. Create and attach request.
|
| - scoped_ptr<Request> req(new Request(
|
| - source_net_log, info, priority, callback, addresses));
|
| - if (out_req)
|
| - *out_req = reinterpret_cast<RequestHandle>(req.get());
|
| -
|
| - job->AddRequest(req.Pass());
|
| - // Completion happens during Job::CompleteRequests().
|
| - return ERR_IO_PENDING;
|
| -}
|
| -
|
| -int HostResolverImpl::ResolveHelper(const Key& key,
|
| - const RequestInfo& info,
|
| - AddressList* addresses,
|
| - const BoundNetLog& source_net_log) {
|
| - // The result of |getaddrinfo| for empty hosts is inconsistent across systems.
|
| - // On Windows it gives the default interface's address, whereas on Linux it
|
| - // gives an error. We will make it fail on all platforms for consistency.
|
| - if (info.hostname().empty() || info.hostname().size() > kMaxHostLength)
|
| - return ERR_NAME_NOT_RESOLVED;
|
| -
|
| - int net_error = ERR_UNEXPECTED;
|
| - if (ResolveAsIP(key, info, &net_error, addresses))
|
| - return net_error;
|
| - if (ServeFromCache(key, info, &net_error, addresses)) {
|
| - source_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CACHE_HIT);
|
| - return net_error;
|
| - }
|
| - // TODO(szym): Do not do this if nsswitch.conf instructs not to.
|
| - // http://crbug.com/117655
|
| - if (ServeFromHosts(key, info, addresses)) {
|
| - source_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_HOSTS_HIT);
|
| - return OK;
|
| - }
|
| - return ERR_DNS_CACHE_MISS;
|
| -}
|
| -
|
| -int HostResolverImpl::ResolveFromCache(const RequestInfo& info,
|
| - AddressList* addresses,
|
| - const BoundNetLog& source_net_log) {
|
| - DCHECK(CalledOnValidThread());
|
| - DCHECK(addresses);
|
| -
|
| - // Update the net log and notify registered observers.
|
| - LogStartRequest(source_net_log, info);
|
| -
|
| - Key key = GetEffectiveKeyForRequest(info, source_net_log);
|
| -
|
| - int rv = ResolveHelper(key, info, addresses, source_net_log);
|
| - LogFinishRequest(source_net_log, info, rv);
|
| - return rv;
|
| -}
|
| -
|
| -void HostResolverImpl::CancelRequest(RequestHandle req_handle) {
|
| - DCHECK(CalledOnValidThread());
|
| - Request* req = reinterpret_cast<Request*>(req_handle);
|
| - DCHECK(req);
|
| - Job* job = req->job();
|
| - DCHECK(job);
|
| - job->CancelRequest(req);
|
| -}
|
| -
|
| -void HostResolverImpl::SetDefaultAddressFamily(AddressFamily address_family) {
|
| - DCHECK(CalledOnValidThread());
|
| - default_address_family_ = address_family;
|
| - probe_ipv6_support_ = false;
|
| -}
|
| -
|
| -AddressFamily HostResolverImpl::GetDefaultAddressFamily() const {
|
| - return default_address_family_;
|
| -}
|
| -
|
| -void HostResolverImpl::SetDnsClientEnabled(bool enabled) {
|
| - DCHECK(CalledOnValidThread());
|
| -#if defined(ENABLE_BUILT_IN_DNS)
|
| - if (enabled && !dns_client_) {
|
| - SetDnsClient(DnsClient::CreateClient(net_log_));
|
| - } else if (!enabled && dns_client_) {
|
| - SetDnsClient(scoped_ptr<DnsClient>());
|
| - }
|
| -#endif
|
| -}
|
| -
|
| -HostCache* HostResolverImpl::GetHostCache() {
|
| - return cache_.get();
|
| -}
|
| -
|
| -base::Value* HostResolverImpl::GetDnsConfigAsValue() const {
|
| - // Check if async DNS is disabled.
|
| - if (!dns_client_.get())
|
| - return NULL;
|
| -
|
| - // Check if async DNS is enabled, but we currently have no configuration
|
| - // for it.
|
| - const DnsConfig* dns_config = dns_client_->GetConfig();
|
| - if (dns_config == NULL)
|
| - return new base::DictionaryValue();
|
| -
|
| - return dns_config->ToValue();
|
| -}
|
| -
|
| -bool HostResolverImpl::ResolveAsIP(const Key& key,
|
| - const RequestInfo& info,
|
| - int* net_error,
|
| - AddressList* addresses) {
|
| - DCHECK(addresses);
|
| - DCHECK(net_error);
|
| - IPAddressNumber ip_number;
|
| - if (!ParseIPLiteralToNumber(key.hostname, &ip_number))
|
| - return false;
|
| -
|
| - DCHECK_EQ(key.host_resolver_flags &
|
| - ~(HOST_RESOLVER_CANONNAME | HOST_RESOLVER_LOOPBACK_ONLY |
|
| - HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6),
|
| - 0) << " Unhandled flag";
|
| -
|
| - *net_error = OK;
|
| - AddressFamily family = GetAddressFamily(ip_number);
|
| - if (family == ADDRESS_FAMILY_IPV6 &&
|
| - !probe_ipv6_support_ &&
|
| - default_address_family_ == ADDRESS_FAMILY_IPV4) {
|
| - // Don't return IPv6 addresses if default address family is set to IPv4,
|
| - // and probes are disabled.
|
| - *net_error = ERR_NAME_NOT_RESOLVED;
|
| - } else if (key.address_family != ADDRESS_FAMILY_UNSPECIFIED &&
|
| - key.address_family != family) {
|
| - // Don't return IPv6 addresses for IPv4 queries, and vice versa.
|
| - *net_error = ERR_NAME_NOT_RESOLVED;
|
| - } else {
|
| - *addresses = AddressList::CreateFromIPAddress(ip_number, info.port());
|
| - if (key.host_resolver_flags & HOST_RESOLVER_CANONNAME)
|
| - addresses->SetDefaultCanonicalName();
|
| - }
|
| - return true;
|
| -}
|
| -
|
| -bool HostResolverImpl::ServeFromCache(const Key& key,
|
| - const RequestInfo& info,
|
| - int* net_error,
|
| - AddressList* addresses) {
|
| - DCHECK(addresses);
|
| - DCHECK(net_error);
|
| - if (!info.allow_cached_response() || !cache_.get())
|
| - return false;
|
| -
|
| - const HostCache::Entry* cache_entry = cache_->Lookup(
|
| - key, base::TimeTicks::Now());
|
| - if (!cache_entry)
|
| - return false;
|
| -
|
| - *net_error = cache_entry->error;
|
| - if (*net_error == OK) {
|
| - if (cache_entry->has_ttl())
|
| - RecordTTL(cache_entry->ttl);
|
| - *addresses = EnsurePortOnAddressList(cache_entry->addrlist, info.port());
|
| - }
|
| - return true;
|
| -}
|
| -
|
| -bool HostResolverImpl::ServeFromHosts(const Key& key,
|
| - const RequestInfo& info,
|
| - AddressList* addresses) {
|
| - DCHECK(addresses);
|
| - if (!HaveDnsConfig())
|
| - return false;
|
| - addresses->clear();
|
| -
|
| - // HOSTS lookups are case-insensitive.
|
| - std::string hostname = base::StringToLowerASCII(key.hostname);
|
| -
|
| - const DnsHosts& hosts = dns_client_->GetConfig()->hosts;
|
| -
|
| - // If |address_family| is ADDRESS_FAMILY_UNSPECIFIED other implementations
|
| - // (glibc and c-ares) return the first matching line. We have more
|
| - // flexibility, but lose implicit ordering.
|
| - // We prefer IPv6 because "happy eyeballs" will fall back to IPv4 if
|
| - // necessary.
|
| - if (key.address_family == ADDRESS_FAMILY_IPV6 ||
|
| - key.address_family == ADDRESS_FAMILY_UNSPECIFIED) {
|
| - DnsHosts::const_iterator it = hosts.find(
|
| - DnsHostsKey(hostname, ADDRESS_FAMILY_IPV6));
|
| - if (it != hosts.end())
|
| - addresses->push_back(IPEndPoint(it->second, info.port()));
|
| - }
|
| -
|
| - if (key.address_family == ADDRESS_FAMILY_IPV4 ||
|
| - key.address_family == ADDRESS_FAMILY_UNSPECIFIED) {
|
| - DnsHosts::const_iterator it = hosts.find(
|
| - DnsHostsKey(hostname, ADDRESS_FAMILY_IPV4));
|
| - if (it != hosts.end())
|
| - addresses->push_back(IPEndPoint(it->second, info.port()));
|
| - }
|
| -
|
| - // 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.address_family = ADDRESS_FAMILY_UNSPECIFIED;
|
| - new_key.host_resolver_flags &=
|
| - ~HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
|
| - return ServeFromHosts(new_key, info, addresses);
|
| - }
|
| - return !addresses->empty();
|
| -}
|
| -
|
| -void HostResolverImpl::CacheResult(const Key& key,
|
| - const HostCache::Entry& entry,
|
| - base::TimeDelta ttl) {
|
| - if (cache_.get())
|
| - cache_->Set(key, entry, base::TimeTicks::Now(), ttl);
|
| -}
|
| -
|
| -void HostResolverImpl::RemoveJob(Job* job) {
|
| - DCHECK(job);
|
| - JobMap::iterator it = jobs_.find(job->key());
|
| - if (it != jobs_.end() && it->second == job)
|
| - jobs_.erase(it);
|
| -}
|
| -
|
| -void HostResolverImpl::SetHaveOnlyLoopbackAddresses(bool result) {
|
| - if (result) {
|
| - additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY;
|
| - } else {
|
| - additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY;
|
| - }
|
| -}
|
| -
|
| -HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
|
| - const RequestInfo& info, const BoundNetLog& net_log) const {
|
| - HostResolverFlags effective_flags =
|
| - info.host_resolver_flags() | additional_resolver_flags_;
|
| - AddressFamily effective_address_family = info.address_family();
|
| -
|
| - if (info.address_family() == ADDRESS_FAMILY_UNSPECIFIED) {
|
| - unsigned char ip_number[4];
|
| - url::Component host_comp(0, info.hostname().size());
|
| - int num_components;
|
| - if (probe_ipv6_support_ && !use_local_ipv6_ &&
|
| - // Don't bother IPv6 probing when resolving IPv4 literals.
|
| - url::IPv4AddressToNumber(info.hostname().c_str(), host_comp, ip_number,
|
| - &num_components) != url::CanonHostInfo::IPV4) {
|
| - // Google DNS address.
|
| - const uint8 kIPv6Address[] =
|
| - { 0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00,
|
| - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88 };
|
| - IPAddressNumber address(kIPv6Address,
|
| - kIPv6Address + arraysize(kIPv6Address));
|
| - BoundNetLog probe_net_log = BoundNetLog::Make(
|
| - net_log.net_log(), NetLog::SOURCE_IPV6_REACHABILITY_CHECK);
|
| - probe_net_log.BeginEvent(NetLog::TYPE_IPV6_REACHABILITY_CHECK,
|
| - net_log.source().ToEventParametersCallback());
|
| - bool rv6 = IsGloballyReachable(address, probe_net_log);
|
| - probe_net_log.EndEvent(NetLog::TYPE_IPV6_REACHABILITY_CHECK);
|
| - if (rv6)
|
| - net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_IPV6_SUPPORTED);
|
| -
|
| - if (rv6) {
|
| - UMA_HISTOGRAM_BOOLEAN("Net.IPv6ConnectSuccessMatch",
|
| - default_address_family_ == ADDRESS_FAMILY_UNSPECIFIED);
|
| - } else {
|
| - UMA_HISTOGRAM_BOOLEAN("Net.IPv6ConnectFailureMatch",
|
| - default_address_family_ != ADDRESS_FAMILY_UNSPECIFIED);
|
| -
|
| - effective_address_family = ADDRESS_FAMILY_IPV4;
|
| - effective_flags |= HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
|
| - }
|
| - } else {
|
| - effective_address_family = default_address_family_;
|
| - }
|
| - }
|
| -
|
| - return Key(info.hostname(), effective_address_family, effective_flags);
|
| -}
|
| -
|
| -void HostResolverImpl::AbortAllInProgressJobs() {
|
| - // In Abort, a Request callback could spawn new Jobs with matching keys, so
|
| - // first collect and remove all running jobs from |jobs_|.
|
| - ScopedVector<Job> jobs_to_abort;
|
| - for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ) {
|
| - Job* job = it->second;
|
| - if (job->is_running()) {
|
| - jobs_to_abort.push_back(job);
|
| - jobs_.erase(it++);
|
| - } else {
|
| - DCHECK(job->is_queued());
|
| - ++it;
|
| - }
|
| - }
|
| -
|
| - // Pause the dispatcher so it won't start any new dispatcher jobs while
|
| - // aborting the old ones. This is needed so that it won't start the second
|
| - // DnsTransaction for a job in |jobs_to_abort| if the DnsConfig just became
|
| - // invalid.
|
| - PrioritizedDispatcher::Limits limits = dispatcher_->GetLimits();
|
| - dispatcher_->SetLimits(
|
| - PrioritizedDispatcher::Limits(limits.reserved_slots.size(), 0));
|
| -
|
| - // Life check to bail once |this| is deleted.
|
| - base::WeakPtr<HostResolverImpl> self = weak_ptr_factory_.GetWeakPtr();
|
| -
|
| - // Then Abort them.
|
| - for (size_t i = 0; self.get() && i < jobs_to_abort.size(); ++i) {
|
| - jobs_to_abort[i]->Abort();
|
| - jobs_to_abort[i] = NULL;
|
| - }
|
| -
|
| - if (self)
|
| - dispatcher_->SetLimits(limits);
|
| -}
|
| -
|
| -void HostResolverImpl::AbortDnsTasks() {
|
| - // Pause the dispatcher so it won't start any new dispatcher jobs while
|
| - // aborting the old ones. This is needed so that it won't start the second
|
| - // DnsTransaction for a job if the DnsConfig just changed.
|
| - PrioritizedDispatcher::Limits limits = dispatcher_->GetLimits();
|
| - dispatcher_->SetLimits(
|
| - PrioritizedDispatcher::Limits(limits.reserved_slots.size(), 0));
|
| -
|
| - for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
|
| - it->second->AbortDnsTask();
|
| - dispatcher_->SetLimits(limits);
|
| -}
|
| -
|
| -void HostResolverImpl::TryServingAllJobsFromHosts() {
|
| - if (!HaveDnsConfig())
|
| - return;
|
| -
|
| - // TODO(szym): Do not do this if nsswitch.conf instructs not to.
|
| - // http://crbug.com/117655
|
| -
|
| - // Life check to bail once |this| is deleted.
|
| - base::WeakPtr<HostResolverImpl> self = weak_ptr_factory_.GetWeakPtr();
|
| -
|
| - for (JobMap::iterator it = jobs_.begin(); self.get() && it != jobs_.end();) {
|
| - Job* job = it->second;
|
| - ++it;
|
| - // This could remove |job| from |jobs_|, but iterator will remain valid.
|
| - job->ServeFromHosts();
|
| - }
|
| -}
|
| -
|
| -void HostResolverImpl::OnIPAddressChanged() {
|
| - resolved_known_ipv6_hostname_ = false;
|
| - // Abandon all ProbeJobs.
|
| - probe_weak_ptr_factory_.InvalidateWeakPtrs();
|
| - if (cache_.get())
|
| - cache_->clear();
|
| -#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
|
| - new LoopbackProbeJob(probe_weak_ptr_factory_.GetWeakPtr());
|
| -#endif
|
| - AbortAllInProgressJobs();
|
| - // |this| may be deleted inside AbortAllInProgressJobs().
|
| -}
|
| -
|
| -void HostResolverImpl::OnDNSChanged() {
|
| - DnsConfig dns_config;
|
| - NetworkChangeNotifier::GetDnsConfig(&dns_config);
|
| -
|
| - if (net_log_) {
|
| - net_log_->AddGlobalEntry(
|
| - NetLog::TYPE_DNS_CONFIG_CHANGED,
|
| - base::Bind(&NetLogDnsConfigCallback, &dns_config));
|
| - }
|
| -
|
| - // TODO(szym): Remove once http://crbug.com/137914 is resolved.
|
| - received_dns_config_ = dns_config.IsValid();
|
| - // Conservatively assume local IPv6 is needed when DnsConfig is not valid.
|
| - use_local_ipv6_ = !dns_config.IsValid() || dns_config.use_local_ipv6;
|
| -
|
| - num_dns_failures_ = 0;
|
| -
|
| - // We want a new DnsSession in place, before we Abort running Jobs, so that
|
| - // the newly started jobs use the new config.
|
| - if (dns_client_.get()) {
|
| - dns_client_->SetConfig(dns_config);
|
| - if (dns_client_->GetConfig())
|
| - UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
|
| - }
|
| -
|
| - // If the DNS server has changed, existing cached info could be wrong so we
|
| - // have to drop our internal cache :( Note that OS level DNS caches, such
|
| - // as NSCD's cache should be dropped automatically by the OS when
|
| - // resolv.conf changes so we don't need to do anything to clear that cache.
|
| - if (cache_.get())
|
| - cache_->clear();
|
| -
|
| - // Life check to bail once |this| is deleted.
|
| - base::WeakPtr<HostResolverImpl> self = weak_ptr_factory_.GetWeakPtr();
|
| -
|
| - // Existing jobs will have been sent to the original server so they need to
|
| - // be aborted.
|
| - AbortAllInProgressJobs();
|
| -
|
| - // |this| may be deleted inside AbortAllInProgressJobs().
|
| - if (self.get())
|
| - TryServingAllJobsFromHosts();
|
| -}
|
| -
|
| -bool HostResolverImpl::HaveDnsConfig() const {
|
| - // Use DnsClient only if it's fully configured and there is no override by
|
| - // ScopedDefaultHostResolverProc.
|
| - // The alternative is to use NetworkChangeNotifier to override DnsConfig,
|
| - // but that would introduce construction order requirements for NCN and SDHRP.
|
| - return (dns_client_.get() != NULL) && (dns_client_->GetConfig() != NULL) &&
|
| - !(proc_params_.resolver_proc.get() == NULL &&
|
| - HostResolverProc::GetDefault() != NULL);
|
| -}
|
| -
|
| -void HostResolverImpl::OnDnsTaskResolve(int net_error) {
|
| - DCHECK(dns_client_);
|
| - if (net_error == OK) {
|
| - num_dns_failures_ = 0;
|
| - return;
|
| - }
|
| - ++num_dns_failures_;
|
| - if (num_dns_failures_ < kMaximumDnsFailures)
|
| - return;
|
| -
|
| - // Disable DnsClient until the next DNS change. Must be done before aborting
|
| - // DnsTasks, since doing so may start new jobs.
|
| - dns_client_->SetConfig(DnsConfig());
|
| -
|
| - // Switch jobs with active DnsTasks over to using ProcTasks.
|
| - AbortDnsTasks();
|
| -
|
| - UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", false);
|
| - UMA_HISTOGRAM_CUSTOM_ENUMERATION("AsyncDNS.DnsClientDisabledReason",
|
| - std::abs(net_error),
|
| - GetAllErrorCodesForUma());
|
| -}
|
| -
|
| -void HostResolverImpl::SetDnsClient(scoped_ptr<DnsClient> dns_client) {
|
| - // DnsClient and config must be updated before aborting DnsTasks, since doing
|
| - // so may start new jobs.
|
| - dns_client_ = dns_client.Pass();
|
| - if (dns_client_ && !dns_client_->GetConfig() &&
|
| - num_dns_failures_ < kMaximumDnsFailures) {
|
| - DnsConfig dns_config;
|
| - NetworkChangeNotifier::GetDnsConfig(&dns_config);
|
| - dns_client_->SetConfig(dns_config);
|
| - num_dns_failures_ = 0;
|
| - if (dns_client_->GetConfig())
|
| - UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
|
| - }
|
| -
|
| - AbortDnsTasks();
|
| -}
|
| -
|
| -} // namespace net
|
|
|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master