net/base/host_resolver_impl.cc - Issue 12518036: net: move host_resolver files from net/base to net/dns

Unified Diff: net/base/host_resolver_impl.cc

Issue 12518036: net: move host_resolver files from net/base to net/dns (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Created 7 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: net/base/host_resolver_impl.cc

diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc

deleted file mode 100644

index ba59569de7f90d6066ceba20ccc8b28b7b34178d..0000000000000000000000000000000000000000

--- a/net/base/host_resolver_impl.cc

+++ /dev/null

@@ -1,2180 +0,0 @@

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-#include "net/base/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_proxy.h"

-#include "base/metrics/field_trial.h"

-#include "base/metrics/histogram.h"

-#include "base/stl_util.h"

-#include "base/string_util.h"

-#include "base/threading/worker_pool.h"

-#include "base/time.h"

-#include "base/utf_string_conversions.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/host_port_pair.h"

-#include "net/base/host_resolver_proc.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"

-#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;

-// Number of consecutive failures of DnsTask (with successful fallback) before

-// the DnsClient is disabled until the next DNS change.

-const unsigned kMaximumDnsFailures = 16;

-// 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);

-// 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);

-//-----------------------------------------------------------------------------

-// Wraps call to SystemHostResolverProc as an instance of HostResolverProc.

-// TODO(szym): This should probably be declared in host_resolver_proc.h.

-class CallSystemHostResolverProc : public HostResolverProc {

- public:

- CallSystemHostResolverProc() : HostResolverProc(NULL) {}

- virtual int Resolve(const std::string& hostname,

- AddressFamily address_family,

- HostResolverFlags host_resolver_flags,

- AddressList* addr_list,

- int* os_error) OVERRIDE {

- return SystemHostResolverProc(hostname,

- address_family,

- host_resolver_flags,

- addr_list,

- os_error);

- }

- protected:

- virtual ~CallSystemHostResolverProc() {}

-};

-AddressList EnsurePortOnAddressList(const AddressList& list, uint16 port) {

- if (list.empty() || list.front().port() == port)

- return list;

- return AddressList::CopyWithPort(list, port);

-// Creates NetLog parameters when the resolve failed.

-base::Value* NetLogProcTaskFailedCallback(uint32 attempt_number,

- int net_error,

- int os_error,

- NetLog::LogLevel /* log_level */) {

- DictionaryValue* dict = new 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;

- int size = 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", 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 */) {

- DictionaryValue* dict = new 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 NetLog::Source& source,

- const HostResolver::RequestInfo* info,

- NetLog::LogLevel /* log_level */) {

- DictionaryValue* dict = new DictionaryValue();

- source.AddToEventParameters(dict);

- 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());

- dict->SetInteger("priority", info->priority());

- 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 */) {

- DictionaryValue* dict = new 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 */) {

- DictionaryValue* dict = new DictionaryValue();

- source.AddToEventParameters(dict);

- dict->SetInteger("priority", 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 BoundNetLog& request_net_log,

- const HostResolver::RequestInfo& info) {

- source_net_log.BeginEvent(

- NetLog::TYPE_HOST_RESOLVER_IMPL,

- request_net_log.source().ToEventParametersCallback());

- request_net_log.BeginEvent(

- NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST,

- base::Bind(&NetLogRequestInfoCallback, source_net_log.source(), &info));

-// Logs when a request has just completed (before its callback is run).

-void LogFinishRequest(const BoundNetLog& source_net_log,

- const BoundNetLog& request_net_log,

- const HostResolver::RequestInfo& info,

- int net_error) {

- request_net_log.EndEventWithNetErrorCode(

- NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST, net_error);

- source_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL);

-// Logs when a request has been cancelled.

-void LogCancelRequest(const BoundNetLog& source_net_log,

- const BoundNetLog& request_net_log,

- const HostResolverImpl::RequestInfo& info) {

- request_net_log.AddEvent(NetLog::TYPE_CANCELLED);

- request_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST);

- source_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL);

-//-----------------------------------------------------------------------------

-// 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

-//-----------------------------------------------------------------------------

-// 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 BoundNetLog& request_net_log,

- const RequestInfo& info,

- const CompletionCallback& callback,

- AddressList* addresses)

- : source_net_log_(source_net_log),

- request_net_log_(request_net_log),

- info_(info),

- 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) {

- 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_;

- }

- // NetLog for this request.

- const BoundNetLog& request_net_log() {

- return request_net_log_;

- }

- const RequestInfo& info() const {

- return info_;

- }

- base::TimeTicks request_time() const {

- return request_time_;

- }

- private:

- BoundNetLog source_net_log_;

- BoundNetLog request_net_log_;

- // The request info that started the request.

- RequestInfo info_;

- // 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)

- params_.resolver_proc = HostResolverProc::GetDefault();

- // If default is unset, use the system proc.

- if (!params_.resolver_proc)

- params_.resolver_proc = new CallSystemHostResolverProc();

- }

- 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) {

- DCHECK(origin_loop_->BelongsToCurrentThread());

- DCHECK(error || !results.empty());

- 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);

- 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 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);

- static const bool show_parallelism_experiment_histograms =

- base::FieldTrialList::TrialExists("DnsParallelism");

- if (show_parallelism_experiment_histograms) {

- UMA_HISTOGRAM_ENUMERATION(

- base::FieldTrial::MakeName("DNS.ResolveCategory", "DnsParallelism"),

- category, RESOLVE_MAX);

- if (RESOLVE_SUCCESS == category) {

- DNS_HISTOGRAM(base::FieldTrial::MakeName("DNS.ResolveSuccess",

- "DnsParallelism"), duration);

- }

- 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 TestIPv6Support to be executed on the WorkerPool as it takes

-// 40-100ms.

-class HostResolverImpl::IPv6ProbeJob {

- public:

- IPv6ProbeJob(const base::WeakPtr<HostResolverImpl>& resolver, NetLog* net_log)

- : resolver_(resolver),

- net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_IPV6_PROBE_JOB)),

- result_(false, IPV6_SUPPORT_MAX, OK) {

- DCHECK(resolver);

- net_log_.BeginEvent(NetLog::TYPE_IPV6_PROBE_RUNNING);

- const bool kIsSlow = true;

- base::WorkerPool::PostTaskAndReply(

- FROM_HERE,

- base::Bind(&IPv6ProbeJob::DoProbe, base::Unretained(this)),

- base::Bind(&IPv6ProbeJob::OnProbeComplete, base::Owned(this)),

- kIsSlow);

- }

- virtual ~IPv6ProbeJob() {}

- private:

- // Runs on worker thread.

- void DoProbe() {

- result_ = TestIPv6Support();

- }

- void OnProbeComplete() {

- net_log_.EndEvent(NetLog::TYPE_IPV6_PROBE_RUNNING,

- base::Bind(&IPv6SupportResult::ToNetLogValue,

- base::Unretained(&result_)));

- if (!resolver_)

- return;

- resolver_->IPv6ProbeSetDefaultAddressFamily(

- result_.ipv6_supported ? ADDRESS_FAMILY_UNSPECIFIED

- : ADDRESS_FAMILY_IPV4);

- }

- // Used/set only on origin thread.

- base::WeakPtr<HostResolverImpl> resolver_;

- BoundNetLog net_log_;

- IPv6SupportResult result_;

- DISALLOW_COPY_AND_ASSIGN(IPv6ProbeJob);

-};

-// 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);

- 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_)

- 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:

- typedef base::Callback<void(int net_error,

- const AddressList& addr_list,

- base::TimeDelta ttl)> Callback;

- DnsTask(DnsClient* client,

- const Key& key,

- const Callback& callback,

- const BoundNetLog& job_net_log)

- : client_(client),

- family_(key.address_family),

- callback_(callback),

- net_log_(job_net_log) {

- DCHECK(client);

- DCHECK(!callback.is_null());

- // If unspecified, do IPv4 first, because suffix search will be faster.

- uint16 qtype = (family_ == ADDRESS_FAMILY_IPV6) ?

- dns_protocol::kTypeAAAA :

- dns_protocol::kTypeA;

- transaction_ = client_->GetTransactionFactory()->CreateTransaction(

- key.hostname,

- qtype,

- base::Bind(&DnsTask::OnTransactionComplete, base::Unretained(this),

- true /* first_query */, base::TimeTicks::Now()),

- net_log_);

- }

- int Start() {

- net_log_.BeginEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK);

- return transaction_->Start();

- }

- private:

- void OnTransactionComplete(bool first_query,

- const base::TimeTicks& start_time,

- DnsTransaction* transaction,

- int net_error,

- const DnsResponse* response) {

- DCHECK(transaction);

- base::TimeDelta duration = base::TimeTicks::Now() - start_time;

- // Run |callback_| last since the owning Job will then delete this DnsTask.

- if (net_error != OK) {

- DNS_HISTOGRAM("AsyncDNS.TransactionFailure", duration);

- OnFailure(net_error, DnsResponse::DNS_PARSE_OK);

- return;

- }

- CHECK(response);

- 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;

- }

- bool needs_sort = false;

- if (first_query) {

- DCHECK(client_->GetConfig()) <<

- "Transaction should have been aborted when config changed!";

- if (family_ == ADDRESS_FAMILY_IPV6) {

- needs_sort = (addr_list.size() > 1);

- } else if (family_ == ADDRESS_FAMILY_UNSPECIFIED) {

- first_addr_list_ = addr_list;

- first_ttl_ = ttl;

- // Use fully-qualified domain name to avoid search.

- transaction_ = client_->GetTransactionFactory()->CreateTransaction(

- response->GetDottedName() + ".",

- dns_protocol::kTypeAAAA,

- base::Bind(&DnsTask::OnTransactionComplete, base::Unretained(this),

- false /* first_query */, base::TimeTicks::Now()),

- net_log_);

- net_error = transaction_->Start();

- if (net_error != ERR_IO_PENDING)

- OnFailure(net_error, DnsResponse::DNS_PARSE_OK);

- return;

- }

- } else {

- DCHECK_EQ(ADDRESS_FAMILY_UNSPECIFIED, family_);

- bool has_ipv6_addresses = !addr_list.empty();

- if (!first_addr_list_.empty()) {

- ttl = std::min(ttl, first_ttl_);

- // Place IPv4 addresses after IPv6.

- addr_list.insert(addr_list.end(), first_addr_list_.begin(),

- first_addr_list_.end());

- }

- needs_sort = (has_ipv6_addresses && addr_list.size() > 1);

- }

- 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 (needs_sort) {

- // Sort could complete synchronously.

- client_->GetAddressSorter()->Sort(

- addr_list,

- base::Bind(&DnsTask::OnSortComplete,

- AsWeakPtr(),

- base::TimeTicks::Now(),

- ttl));

- } else {

- OnSuccess(addr_list, ttl);

- }

- void OnSortComplete(base::TimeTicks start_time,

- base::TimeDelta ttl,

- 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, ttl);

- }

- 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));

- callback_.Run(net_error, AddressList(), base::TimeDelta());

- }

- void OnSuccess(const AddressList& addr_list, base::TimeDelta ttl) {

- net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK,

- addr_list.CreateNetLogCallback());

- callback_.Run(OK, addr_list, ttl);

- }

- DnsClient* client_;

- AddressFamily family_;

- // The listener to the results of this DnsTask.

- Callback callback_;

- const BoundNetLog net_log_;

- scoped_ptr<DnsTransaction> transaction_;

- // Results from the first transaction. Used only if |family_| is unspecified.

- AddressList first_addr_list_;

- base::TimeDelta first_ttl_;

- DISALLOW_COPY_AND_ASSIGN(DnsTask);

-};

-//-----------------------------------------------------------------------------

-// Aggregates all Requests for the same Key. Dispatched via PriorityDispatch.

-class HostResolverImpl::Job : public PrioritizedDispatcher::Job {

- 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& request_net_log)

- : resolver_(resolver),

- key_(key),

- priority_tracker_(priority),

- had_non_speculative_request_(false),

- had_dns_config_(false),

- dns_task_error_(OK),

- creation_time_(base::TimeTicks::Now()),

- priority_change_time_(creation_time_),

- net_log_(BoundNetLog::Make(request_net_log.net_log(),

- NetLog::SOURCE_HOST_RESOLVER_IMPL_JOB)) {

- request_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CREATE_JOB);

- net_log_.BeginEvent(

- NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,

- base::Bind(&NetLogJobCreationCallback,

- request_net_log.source(),

- &key_.hostname));

- }

- virtual ~Job() {

- 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.

- dns_task_.reset(NULL);

- 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->request_net_log(),

- req->info());

- }

- // Add this job to the dispatcher.

- void Schedule() {

- handle_ = resolver_->dispatcher_.Add(this, priority());

- }

- void AddRequest(scoped_ptr<Request> req) {

- DCHECK_EQ(key_.hostname, req->info().hostname());

- req->set_job(this);

- priority_tracker_.Add(req->info().priority());

- req->request_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->request_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_)

- 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->request_net_log(),

- req->info());

- priority_tracker_.Remove(req->info().priority());

- net_log_.AddEvent(

- NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_DETACH,

- base::Bind(&NetLogJobAttachCallback,

- req->request_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_) {

- dns_task_.reset();

- 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 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:

- virtual void Start() OVERRIDE {

- DCHECK(!is_running());

- handle_.Reset();

- 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);

- }

- // Caution: Job::Start must not complete synchronously.

- if (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) {

- 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;

- }

- 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_,

- base::Bind(&Job::OnDnsTaskComplete, base::Unretained(this),

- base::TimeTicks::Now()),

- net_log_));

- int rv = dns_task_->Start();

- if (rv != ERR_IO_PENDING) {

- DCHECK_NE(OK, rv);

- dns_task_error_ = rv;

- dns_task_.reset();

- StartProcTask();

- }

- // Called by DnsTask when it completes.

- void OnDnsTaskComplete(base::TimeTicks start_time,

- int net_error,

- const AddressList& addr_list,

- base::TimeDelta ttl) {

- DCHECK(is_dns_running());

- base::TimeDelta duration = base::TimeTicks::Now() - start_time;

- if (net_error != OK) {

- DNS_HISTOGRAM("AsyncDNS.ResolveFail", duration);

- dns_task_error_ = net_error;

- dns_task_.reset();

- // 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.

- StartProcTask();

- 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);

- }

- // Performs Job's last rites. Completes all Requests. Deletes this.

- void CompleteRequests(const HostCache::Entry& entry,

- base::TimeDelta ttl) {

- CHECK(resolver_);

- // 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()) {

- DCHECK(!is_queued());

- if (is_proc_running()) {

- proc_task_->Cancel();

- proc_task_ = NULL;

- }

- dns_task_.reset();

- // 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);

- // 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->request_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_)

- 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_;

- // 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) {

-HostResolverImpl::ProcTaskParams::~ProcTaskParams() {}

-HostResolverImpl::HostResolverImpl(

- scoped_ptr<HostCache> cache,

- const PrioritizedDispatcher::Limits& job_limits,

- const ProcTaskParams& proc_params,

- NetLog* net_log)

- : cache_(cache.Pass()),

- dispatcher_(job_limits),

- max_queued_jobs_(job_limits.total_jobs * 100u),

- proc_params_(proc_params),

- net_log_(net_log),

- default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),

- weak_ptr_factory_(this),

- probe_weak_ptr_factory_(this),

- received_dns_config_(false),

- num_dns_failures_(0),

- ipv6_probe_monitoring_(false),

- resolved_known_ipv6_hostname_(false),

- additional_resolver_flags_(0) {

- DCHECK_GE(dispatcher_.num_priorities(), static_cast<size_t>(NUM_PRIORITIES));

- // Maximum of 4 retry attempts for host resolution.

- static const size_t kDefaultMaxRetryAttempts = 4u;

- if (proc_params_.max_retry_attempts == HostResolver::kDefaultRetryAttempts)

- proc_params_.max_retry_attempts = kDefaultMaxRetryAttempts;

-#if defined(OS_WIN)

- EnsureWinsockInit();

-#endif

-#if defined(OS_POSIX) && !defined(OS_MACOSX)

- 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

- // TODO(szym): Remove when received_dns_config_ is removed, once

- // http://crbug.com/137914 is resolved.

- {

- DnsConfig dns_config;

- NetworkChangeNotifier::GetDnsConfig(&dns_config);

- received_dns_config_ = dns_config.IsValid();

- }

-HostResolverImpl::~HostResolverImpl() {

- // This will also cancel all outstanding requests.

- 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,

- AddressList* addresses,

- const CompletionCallback& callback,

- RequestHandle* out_req,

- const BoundNetLog& source_net_log) {

- DCHECK(addresses);

- DCHECK(CalledOnValidThread());

- DCHECK_EQ(false, callback.is_null());

- // Make a log item for the request.

- BoundNetLog request_net_log = BoundNetLog::Make(net_log_,

- NetLog::SOURCE_HOST_RESOLVER_IMPL_REQUEST);

- LogStartRequest(source_net_log, request_net_log, info);

- // Build a key that identifies the request in the cache and in the

- // outstanding jobs map.

- Key key = GetEffectiveKeyForRequest(info);

- int rv = ResolveHelper(key, info, addresses, request_net_log);

- if (rv != ERR_DNS_CACHE_MISS) {

- LogFinishRequest(source_net_log, request_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, info.priority(),

- request_net_log);

- job->Schedule();

- // 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, request_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,

- request_net_log,

- info,

- 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& request_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)) {

- request_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)) {

- request_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);

- // Make a log item for the request.

- BoundNetLog request_net_log = BoundNetLog::Make(net_log_,

- NetLog::SOURCE_HOST_RESOLVER_IMPL_REQUEST);

- // Update the net log and notify registered observers.

- LogStartRequest(source_net_log, request_net_log, info);

- Key key = GetEffectiveKeyForRequest(info);

- int rv = ResolveHelper(key, info, addresses, request_net_log);

- LogFinishRequest(source_net_log, request_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;

- ipv6_probe_monitoring_ = false;

-AddressFamily HostResolverImpl::GetDefaultAddressFamily() const {

- return default_address_family_;

-void HostResolverImpl::ProbeIPv6Support() {

- DCHECK(CalledOnValidThread());

- DCHECK(!ipv6_probe_monitoring_);

- ipv6_probe_monitoring_ = true;

- OnIPAddressChanged();

-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 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";

- bool ipv6_disabled = (default_address_family_ == ADDRESS_FAMILY_IPV4) &&

- !ipv6_probe_monitoring_;

- *net_error = OK;

- if ((ip_number.size() == kIPv6AddressSize) && ipv6_disabled) {

- *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;

- // HOSTS lookups are case-insensitive.

- std::string hostname = StringToLowerASCII(key.hostname);

- // 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.

- // TODO(szym) http://crbug.com/117850

- const DnsHosts& hosts = dns_client_->GetConfig()->hosts;

- DnsHosts::const_iterator it = hosts.find(

- DnsHostsKey(hostname,

- key.address_family == ADDRESS_FAMILY_UNSPECIFIED ?

- ADDRESS_FAMILY_IPV4 : key.address_family));

- if (it == hosts.end()) {

- if (key.address_family != ADDRESS_FAMILY_UNSPECIFIED)

- return false;

- it = hosts.find(DnsHostsKey(hostname, ADDRESS_FAMILY_IPV6));

- if (it == hosts.end())

- return false;

- }

- *addresses = AddressList::CreateFromIPAddress(it->second, info.port());

- return true;

-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::IPv6ProbeSetDefaultAddressFamily(

- AddressFamily address_family) {

- DCHECK(address_family == ADDRESS_FAMILY_UNSPECIFIED ||

- address_family == ADDRESS_FAMILY_IPV4);

- if (!ipv6_probe_monitoring_)

- return;

- if (default_address_family_ != address_family) {

- VLOG(1) << "IPv6Probe forced AddressFamily setting to "

- << ((address_family == ADDRESS_FAMILY_UNSPECIFIED) ?

- "ADDRESS_FAMILY_UNSPECIFIED" : "ADDRESS_FAMILY_IPV4");

- }

- default_address_family_ = address_family;

-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 {

- HostResolverFlags effective_flags =

- info.host_resolver_flags() | additional_resolver_flags_;

- AddressFamily effective_address_family = info.address_family();

- if (effective_address_family == ADDRESS_FAMILY_UNSPECIFIED &&

- default_address_family_ != ADDRESS_FAMILY_UNSPECIFIED) {

- effective_address_family = default_address_family_;

- if (ipv6_probe_monitoring_)

- effective_flags |= HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;

- }

- 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;

- }

- // Check if no dispatcher slots leaked out.

- DCHECK_EQ(dispatcher_.num_running_jobs(), jobs_to_abort.size());

- // 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 && i < jobs_to_abort.size(); ++i) {

- jobs_to_abort[i]->Abort();

- jobs_to_abort[i] = NULL;

- }

-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 && 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 (ipv6_probe_monitoring_)

- new IPv6ProbeJob(probe_weak_ptr_factory_.GetWeakPtr(), net_log_);

-#if defined(OS_POSIX) && !defined(OS_MACOSX)

- 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();

- 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_config.IsValid())

- 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)

- 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 == 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.

- for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ++it)

- it->second->AbortDnsTask();

- dns_client_->SetConfig(DnsConfig());

- 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) {

- if (HaveDnsConfig()) {

- for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ++it)

- it->second->AbortDnsTask();

- }

- dns_client_ = dns_client.Pass();

- if (!dns_client_ || dns_client_->GetConfig() ||

- num_dns_failures_ >= kMaximumDnsFailures) {

- return;

- }

- DnsConfig dns_config;

- NetworkChangeNotifier::GetDnsConfig(&dns_config);

- dns_client_->SetConfig(dns_config);

- num_dns_failures_ = 0;

- if (dns_config.IsValid())

- UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);

-} // namespace net

« no previous file with comments | « net/base/host_resolver_impl.h ('k') | net/base/host_resolver_impl_unittest.cc » ('j') | webkit/DEPS » ('J')