Provide Shill IP Address to myIpAddress()

net/dns/host_resolver_impl.cc

 // 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>
@@ skipping 1240 matching lines @@
                        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());
+      handle = resolver_->dispatcher_->Add(this, priority());
     } else {
-      handle = resolver_->dispatcher_.AddAtHead(this, priority());
+      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;
     }
   }
 
@@ skipping 118 matching lines @@
     }
   }
 
   // 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_);
+      resolver_->dispatcher_->Cancel(handle_);
       handle_.Reset();
     } else if (num_occupied_job_slots_ > 1) {
-      resolver_->dispatcher_.OnJobFinished();
+      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());
+      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:
@@ skipping 226 matching lines @@
 
     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();
+      resolver_->dispatcher_->OnJobFinished();
     } else if (is_queued()) {
-      resolver_->dispatcher_.Cancel(handle_);
+      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;
     }
 
@@ skipping 101 matching lines @@
 
 //-----------------------------------------------------------------------------
 
 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(
-    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),
+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();
 
-  DCHECK_GE(dispatcher_.num_priorities(), static_cast<size_t>(NUM_PRIORITIES));
+  PrioritizedDispatcher::Limits job_limits = options.GetDispatcherLimits();
+  dispatcher_.reset(new PrioritizedDispatcher(job_limits));
+  max_queued_jobs_ = job_limits.total_jobs * 100u;
 
-  // 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;
+  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();
+  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_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) {
@@ skipping 27 matching lines @@
   // 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, request_net_log);
     job->Schedule(false);
 
     // Check for queue overflow.
-    if (dispatcher_.num_queued_jobs() > max_queued_jobs_) {
-      Job* evicted = static_cast<Job*>(dispatcher_.EvictOldestLowest());
+    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 {
@@ skipping 281 matching lines @@
     } 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 = 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);
+    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 = 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);
+  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.
@@ skipping 108 matching lines @@
     dns_client_->SetConfig(dns_config);
     num_dns_failures_ = 0;
     if (dns_client_->GetConfig())
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
   }
 
   AbortDnsTasks();
 }
 
 }  // namespace net