Home | History | Annotate | Download | only in dns 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/dns/host_resolver.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/metrics/field_trial.h"
      9 #include "base/strings/string_number_conversions.h"
     10 #include "base/strings/string_split.h"
     11 #include "net/dns/dns_client.h"
     12 #include "net/dns/dns_config_service.h"
     13 #include "net/dns/host_cache.h"
     14 #include "net/dns/host_resolver_impl.h"
     15 
     16 namespace net {
     17 
     18 namespace {
     19 
     20 // Maximum of 6 concurrent resolver threads (excluding retries).
     21 // Some routers (or resolvers) appear to start to provide host-not-found if
     22 // too many simultaneous resolutions are pending.  This number needs to be
     23 // further optimized, but 8 is what FF currently does. We found some routers
     24 // that limit this to 6, so we're temporarily holding it at that level.
     25 const size_t kDefaultMaxProcTasks = 6u;
     26 
     27 }  // namespace
     28 
     29 PrioritizedDispatcher::Limits HostResolver::Options::GetDispatcherLimits()
     30     const {
     31   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, max_concurrent_resolves);
     32 
     33   // If not using default, do not use the field trial.
     34   if (limits.total_jobs != HostResolver::kDefaultParallelism)
     35     return limits;
     36 
     37   // Default, without trial is no reserved slots.
     38   limits.total_jobs = kDefaultMaxProcTasks;
     39 
     40   // Parallelism is determined by the field trial.
     41   std::string group = base::FieldTrialList::FindFullName(
     42       "HostResolverDispatch");
     43 
     44   if (group.empty())
     45     return limits;
     46 
     47   // The format of the group name is a list of non-negative integers separated
     48   // by ':'. Each of the elements in the list corresponds to an element in
     49   // |reserved_slots|, except the last one which is the |total_jobs|.
     50 
     51   std::vector<std::string> group_parts;
     52   base::SplitString(group, ':', &group_parts);
     53   if (group_parts.size() != NUM_PRIORITIES + 1) {
     54     NOTREACHED();
     55     return limits;
     56   }
     57 
     58   std::vector<size_t> parsed(group_parts.size());
     59   size_t total_reserved_slots = 0;
     60 
     61   for (size_t i = 0; i < group_parts.size(); ++i) {
     62     if (!base::StringToSizeT(group_parts[i], &parsed[i])) {
     63       NOTREACHED();
     64       return limits;
     65     }
     66   }
     67 
     68   size_t total_jobs = parsed.back();
     69   parsed.pop_back();
     70   for (size_t i = 0; i < parsed.size(); ++i) {
     71     total_reserved_slots += parsed[i];
     72   }
     73 
     74   // There must be some unreserved slots available for the all priorities.
     75   if (total_reserved_slots > total_jobs ||
     76       (total_reserved_slots == total_jobs && parsed[MINIMUM_PRIORITY] == 0)) {
     77     NOTREACHED();
     78     return limits;
     79   }
     80 
     81   limits.total_jobs = total_jobs;
     82   limits.reserved_slots = parsed;
     83   return limits;
     84 }
     85 
     86 HostResolver::Options::Options()
     87     : max_concurrent_resolves(kDefaultParallelism),
     88       max_retry_attempts(kDefaultRetryAttempts),
     89       enable_caching(true) {
     90 }
     91 
     92 HostResolver::RequestInfo::RequestInfo(const HostPortPair& host_port_pair)
     93     : host_port_pair_(host_port_pair),
     94       address_family_(ADDRESS_FAMILY_UNSPECIFIED),
     95       host_resolver_flags_(0),
     96       allow_cached_response_(true),
     97       is_speculative_(false),
     98       is_my_ip_address_(false) {}
     99 
    100 HostResolver::~HostResolver() {
    101 }
    102 
    103 AddressFamily HostResolver::GetDefaultAddressFamily() const {
    104   return ADDRESS_FAMILY_UNSPECIFIED;
    105 }
    106 
    107 void HostResolver::SetDnsClientEnabled(bool enabled) {
    108 }
    109 
    110 HostCache* HostResolver::GetHostCache() {
    111   return NULL;
    112 }
    113 
    114 base::Value* HostResolver::GetDnsConfigAsValue() const {
    115   return NULL;
    116 }
    117 
    118 // static
    119 scoped_ptr<HostResolver> HostResolver::CreateSystemResolver(
    120     const Options& options,
    121     NetLog* net_log) {
    122   return scoped_ptr<HostResolver>(new HostResolverImpl(options, net_log));
    123 }
    124 
    125 // static
    126 scoped_ptr<HostResolver> HostResolver::CreateDefaultResolver(NetLog* net_log) {
    127   return scoped_ptr<HostResolver>(new HostResolverImpl(Options(), net_log));
    128 }
    129 
    130 HostResolver::HostResolver() {
    131 }
    132 
    133 }  // namespace net
    134