Remove //net (except for Android test stuff) and sdch

net/dns/dns_config_service.cc

Index: net/dns/dns_config_service.cc
diff --git a/net/dns/dns_config_service.cc b/net/dns/dns_config_service.cc
deleted file mode 100644
index bfa4b8db84e648393eecfd4ce8a4d82ff6afcce7..0000000000000000000000000000000000000000
--- a/net/dns/dns_config_service.cc
+++ /dev/null
@@ -1,320 +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/dns_config_service.h"
-
-#include "base/logging.h"
-#include "base/metrics/histogram.h"
-#include "base/values.h"
-#include "net/base/ip_endpoint.h"
-#include "net/base/ip_pattern.h"
-
-namespace net {
-
-NameServerClassifier::NameServerClassifier() {
-  // Google Public DNS addresses from:
-  // https://developers.google.com/speed/public-dns/docs/using
-  AddRule("8.8.8.8", NAME_SERVERS_TYPE_GOOGLE_PUBLIC_DNS);
-  AddRule("8.8.4.4", NAME_SERVERS_TYPE_GOOGLE_PUBLIC_DNS);
-  AddRule("2001:4860:4860:0:0:0:0:8888", NAME_SERVERS_TYPE_GOOGLE_PUBLIC_DNS),
-  AddRule("2001:4860:4860:0:0:0:0:8844", NAME_SERVERS_TYPE_GOOGLE_PUBLIC_DNS),
-
-  // Count localhost as private, since we don't know what upstream it uses:
-  AddRule("127.*.*.*", NAME_SERVERS_TYPE_PRIVATE);
-  AddRule("0:0:0:0:0:0:0:1", NAME_SERVERS_TYPE_PRIVATE);
-
-  // RFC 1918 private addresses:
-  AddRule("10.*.*.*", NAME_SERVERS_TYPE_PRIVATE);
-  AddRule("172.[16-31].*.*", NAME_SERVERS_TYPE_PRIVATE);
-  AddRule("192.168.*.*", NAME_SERVERS_TYPE_PRIVATE);
-
-  // IPv4 link-local addresses:
-  AddRule("169.254.*.*", NAME_SERVERS_TYPE_PRIVATE);
-
-  // IPv6 link-local addresses:
-  AddRule("fe80:*:*:*:*:*:*:*", NAME_SERVERS_TYPE_PRIVATE);
-
-  // Anything else counts as public:
-  AddRule("*.*.*.*", NAME_SERVERS_TYPE_PUBLIC);
-  AddRule("*:*:*:*:*:*:*:*", NAME_SERVERS_TYPE_PUBLIC);
-}
-
-NameServerClassifier::~NameServerClassifier() {}
-
-NameServerClassifier::NameServersType NameServerClassifier::GetNameServersType(
-    const std::vector<IPEndPoint>& nameservers) const {
-  NameServersType type = NAME_SERVERS_TYPE_NONE;
-  for (std::vector<IPEndPoint>::const_iterator it = nameservers.begin();
-       it != nameservers.end();
-       ++it) {
-    type = MergeNameServersTypes(type, GetNameServerType(it->address()));
-  }
-  return type;
-}
-
-struct NameServerClassifier::NameServerTypeRule {
-  NameServerTypeRule(const char* pattern_string, NameServersType type)
-      : type(type) {
-    bool parsed = pattern.ParsePattern(pattern_string);
-    DCHECK(parsed);
-  }
-
-  IPPattern pattern;
-  NameServersType type;
-};
-
-void NameServerClassifier::AddRule(const char* pattern_string,
-                                   NameServersType address_type) {
-  rules_.push_back(new NameServerTypeRule(pattern_string, address_type));
-}
-
-NameServerClassifier::NameServersType NameServerClassifier::GetNameServerType(
-    const IPAddressNumber& address) const {
-  for (ScopedVector<NameServerTypeRule>::const_iterator it = rules_.begin();
-       it != rules_.end();
-       ++it) {
-    if ((*it)->pattern.Match(address))
-      return (*it)->type;
-  }
-  NOTREACHED();
-  return NAME_SERVERS_TYPE_NONE;
-}
-
-NameServerClassifier::NameServersType
-NameServerClassifier::MergeNameServersTypes(NameServersType a,
-                                            NameServersType b) {
-  if (a == NAME_SERVERS_TYPE_NONE)
-    return b;
-  if (b == NAME_SERVERS_TYPE_NONE)
-    return a;
-  if (a == b)
-    return a;
-  return NAME_SERVERS_TYPE_MIXED;
-}
-
-// Default values are taken from glibc resolv.h except timeout which is set to
-// |kDnsTimeoutSeconds|.
-DnsConfig::DnsConfig()
-    : unhandled_options(false),
-      append_to_multi_label_name(true),
-      randomize_ports(false),
-      ndots(1),
-      timeout(base::TimeDelta::FromSeconds(kDnsTimeoutSeconds)),
-      attempts(2),
-      rotate(false),
-      edns0(false),
-      use_local_ipv6(false) {}
-
-DnsConfig::~DnsConfig() {}
-
-bool DnsConfig::Equals(const DnsConfig& d) const {
-  return EqualsIgnoreHosts(d) && (hosts == d.hosts);
-}
-
-bool DnsConfig::EqualsIgnoreHosts(const DnsConfig& d) const {
-  return (nameservers == d.nameservers) &&
-         (search == d.search) &&
-         (unhandled_options == d.unhandled_options) &&
-         (append_to_multi_label_name == d.append_to_multi_label_name) &&
-         (ndots == d.ndots) &&
-         (timeout == d.timeout) &&
-         (attempts == d.attempts) &&
-         (rotate == d.rotate) &&
-         (edns0 == d.edns0) &&
-         (use_local_ipv6 == d.use_local_ipv6);
-}
-
-void DnsConfig::CopyIgnoreHosts(const DnsConfig& d) {
-  nameservers = d.nameservers;
-  search = d.search;
-  unhandled_options = d.unhandled_options;
-  append_to_multi_label_name = d.append_to_multi_label_name;
-  ndots = d.ndots;
-  timeout = d.timeout;
-  attempts = d.attempts;
-  rotate = d.rotate;
-  edns0 = d.edns0;
-  use_local_ipv6 = d.use_local_ipv6;
-}
-
-base::Value* DnsConfig::ToValue() const {
-  base::DictionaryValue* dict = new base::DictionaryValue();
-
-  base::ListValue* list = new base::ListValue();
-  for (size_t i = 0; i < nameservers.size(); ++i)
-    list->Append(new base::StringValue(nameservers[i].ToString()));
-  dict->Set("nameservers", list);
-
-  list = new base::ListValue();
-  for (size_t i = 0; i < search.size(); ++i)
-    list->Append(new base::StringValue(search[i]));
-  dict->Set("search", list);
-
-  dict->SetBoolean("unhandled_options", unhandled_options);
-  dict->SetBoolean("append_to_multi_label_name", append_to_multi_label_name);
-  dict->SetInteger("ndots", ndots);
-  dict->SetDouble("timeout", timeout.InSecondsF());
-  dict->SetInteger("attempts", attempts);
-  dict->SetBoolean("rotate", rotate);
-  dict->SetBoolean("edns0", edns0);
-  dict->SetBoolean("use_local_ipv6", use_local_ipv6);
-  dict->SetInteger("num_hosts", hosts.size());
-
-  return dict;
-}
-
-
-DnsConfigService::DnsConfigService()
-    : watch_failed_(false),
-      have_config_(false),
-      have_hosts_(false),
-      need_update_(false),
-      last_sent_empty_(true) {}
-
-DnsConfigService::~DnsConfigService() {
-}
-
-void DnsConfigService::ReadConfig(const CallbackType& callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!callback.is_null());
-  DCHECK(callback_.is_null());
-  callback_ = callback;
-  ReadNow();
-}
-
-void DnsConfigService::WatchConfig(const CallbackType& callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!callback.is_null());
-  DCHECK(callback_.is_null());
-  callback_ = callback;
-  watch_failed_ = !StartWatching();
-  ReadNow();
-}
-
-void DnsConfigService::InvalidateConfig() {
-  DCHECK(CalledOnValidThread());
-  base::TimeTicks now = base::TimeTicks::Now();
-  if (!last_invalidate_config_time_.is_null()) {
-    UMA_HISTOGRAM_LONG_TIMES("AsyncDNS.ConfigNotifyInterval",
-                             now - last_invalidate_config_time_);
-  }
-  last_invalidate_config_time_ = now;
-  if (!have_config_)
-    return;
-  have_config_ = false;
-  StartTimer();
-}
-
-void DnsConfigService::InvalidateHosts() {
-  DCHECK(CalledOnValidThread());
-  base::TimeTicks now = base::TimeTicks::Now();
-  if (!last_invalidate_hosts_time_.is_null()) {
-    UMA_HISTOGRAM_LONG_TIMES("AsyncDNS.HostsNotifyInterval",
-                             now - last_invalidate_hosts_time_);
-  }
-  last_invalidate_hosts_time_ = now;
-  if (!have_hosts_)
-    return;
-  have_hosts_ = false;
-  StartTimer();
-}
-
-void DnsConfigService::OnConfigRead(const DnsConfig& config) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(config.IsValid());
-
-  bool changed = false;
-  if (!config.EqualsIgnoreHosts(dns_config_)) {
-    dns_config_.CopyIgnoreHosts(config);
-    need_update_ = true;
-    changed = true;
-  }
-  if (!changed && !last_sent_empty_time_.is_null()) {
-    UMA_HISTOGRAM_LONG_TIMES("AsyncDNS.UnchangedConfigInterval",
-                             base::TimeTicks::Now() - last_sent_empty_time_);
-  }
-  UMA_HISTOGRAM_BOOLEAN("AsyncDNS.ConfigChange", changed);
-  UMA_HISTOGRAM_ENUMERATION(
-      "AsyncDNS.NameServersType",
-      classifier_.GetNameServersType(dns_config_.nameservers),
-      NameServerClassifier::NAME_SERVERS_TYPE_MAX_VALUE);
-
-  have_config_ = true;
-  if (have_hosts_ || watch_failed_)
-    OnCompleteConfig();
-}
-
-void DnsConfigService::OnHostsRead(const DnsHosts& hosts) {
-  DCHECK(CalledOnValidThread());
-
-  bool changed = false;
-  if (hosts != dns_config_.hosts) {
-    dns_config_.hosts = hosts;
-    need_update_ = true;
-    changed = true;
-  }
-  if (!changed && !last_sent_empty_time_.is_null()) {
-    UMA_HISTOGRAM_LONG_TIMES("AsyncDNS.UnchangedHostsInterval",
-                             base::TimeTicks::Now() - last_sent_empty_time_);
-  }
-  UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HostsChange", changed);
-
-  have_hosts_ = true;
-  if (have_config_ || watch_failed_)
-    OnCompleteConfig();
-}
-
-void DnsConfigService::StartTimer() {
-  DCHECK(CalledOnValidThread());
-  if (last_sent_empty_) {
-    DCHECK(!timer_.IsRunning());
-    return;  // No need to withdraw again.
-  }
-  timer_.Stop();
-
-  // Give it a short timeout to come up with a valid config. Otherwise withdraw
-  // the config from the receiver. The goal is to avoid perceivable network
-  // outage (when using the wrong config) but at the same time avoid
-  // unnecessary Job aborts in HostResolverImpl. The signals come from multiple
-  // sources so it might receive multiple events during a config change.
-
-  // DHCP and user-induced changes are on the order of seconds, so 150ms should
-  // not add perceivable delay. On the other hand, config readers should finish
-  // within 150ms with the rare exception of I/O block or extra large HOSTS.
-  const base::TimeDelta kTimeout = base::TimeDelta::FromMilliseconds(150);
-
-  timer_.Start(FROM_HERE,
-               kTimeout,
-               this,
-               &DnsConfigService::OnTimeout);
-}
-
-void DnsConfigService::OnTimeout() {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!last_sent_empty_);
-  // Indicate that even if there is no change in On*Read, we will need to
-  // update the receiver when the config becomes complete.
-  need_update_ = true;
-  // Empty config is considered invalid.
-  last_sent_empty_ = true;
-  last_sent_empty_time_ = base::TimeTicks::Now();
-  callback_.Run(DnsConfig());
-}
-
-void DnsConfigService::OnCompleteConfig() {
-  timer_.Stop();
-  if (!need_update_)
-    return;
-  need_update_ = false;
-  last_sent_empty_ = false;
-  if (watch_failed_) {
-    // If a watch failed, the config may not be accurate, so report empty.
-    callback_.Run(DnsConfig());
-  } else {
-    callback_.Run(dns_config_);
-  }
-}
-
-}  // namespace net
-