[net] Move DnsConfigService to NetworkChangeNotifier.

net/base/network_change_notifier.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/base/network_change_notifier.h"
-#include "net/base/network_change_notifier_factory.h"
+
 #include "base/metrics/histogram.h"
+#include "base/synchronization/lock.h"
 #include "build/build_config.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
+#include "net/base/network_change_notifier_factory.h"
+#include "net/dns/dns_config_service.h"
+
 #if defined(OS_WIN)
 #include "net/base/network_change_notifier_win.h"
 #elif defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include "net/base/network_change_notifier_linux.h"
 #elif defined(OS_MACOSX)
 #include "net/base/network_change_notifier_mac.h"
 #endif
 
 namespace net {
 
@@ skipping 28 matching lines @@
         last_connection_change_(base::TimeTicks::Now()),
         last_dns_change_(base::TimeTicks::Now()),
         last_connection_type_(NetworkChangeNotifier::CONNECTION_UNKNOWN),
         offline_packets_received_(0) {}
 
   // Registers our three Observer implementations.  This is called from the
   // network thread so that our Observer implementations are also called
   // from the network thread.  This avoids multi-threaded race conditions
   // because the only other interface, |NotifyDataReceived| is also
   // only called from the network thread.
-  void InitHistogramWatcher() {
+  void Init() {
     NetworkChangeNotifier::AddConnectionTypeObserver(this);
     NetworkChangeNotifier::AddIPAddressObserver(this);
     NetworkChangeNotifier::AddDNSObserver(this);
   }
 
   virtual ~HistogramWatcher() {}
 
   // NetworkChangeNotifier::IPAddressObserver implementation.
   virtual void OnIPAddressChanged() OVERRIDE {
     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.IPAddressChange",
@@ skipping 23 matching lines @@
     } else {
       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineChange",
                                  SinceLast(&last_connection_change_));
     }
 
     offline_packets_received_ = 0;
     last_connection_type_ = type;
   }
 
   // NetworkChangeNotifier::DNSObserver implementation.
-  virtual void OnDNSChanged(unsigned detail) OVERRIDE {
-    if (detail == NetworkChangeNotifier::CHANGE_DNS_SETTINGS) {
-      UMA_HISTOGRAM_MEDIUM_TIMES("NCN.DNSConfigChange",
-                                 SinceLast(&last_dns_change_));
-    }
+  virtual void OnDNSChanged() OVERRIDE {
+    UMA_HISTOGRAM_MEDIUM_TIMES("NCN.DNSConfigChange",
+                               SinceLast(&last_dns_change_));
   }
 
   // Record histogram data whenever we receive a packet but think we're
   // offline.  Should only be called from the network thread.
   void NotifyDataReceived(const GURL& source) {
     if (last_connection_type_ != NetworkChangeNotifier::CONNECTION_NONE ||
         IsLocalhost(source.host()) ||
         !(source.SchemeIs("http") || source.SchemeIs("https"))) {
       return;
     }
@@ skipping 16 matching lines @@
   base::TimeTicks last_ip_address_change_;
   base::TimeTicks last_connection_change_;
   base::TimeTicks last_dns_change_;
   base::TimeTicks last_offline_packet_received_;
   NetworkChangeNotifier::ConnectionType last_connection_type_;
   int32 offline_packets_received_;
 
   DISALLOW_COPY_AND_ASSIGN(HistogramWatcher);
 };
 
+// NetworkState is thread safe.
+class NetworkChangeNotifier::NetworkState {
+ public:
+  NetworkState() {}
+  ~NetworkState() {}
+
+  void GetDnsConfig(DnsConfig* config) const {
+    base::AutoLock lock(lock_);
+    *config = dns_config_;
+  }
+
+  void SetDnsConfig(const DnsConfig& dns_config) {
+    base::AutoLock lock(lock_);
+    dns_config_ = dns_config;
+  }
+
+ private:
+  mutable base::Lock lock_;
+  DnsConfig dns_config_;
+};
+
 NetworkChangeNotifier::~NetworkChangeNotifier() {
   DCHECK_EQ(this, g_network_change_notifier);
   g_network_change_notifier = NULL;
 }
 
 // static
 void NetworkChangeNotifier::SetFactory(
     NetworkChangeNotifierFactory* factory) {
   CHECK(!g_network_change_notifier_factory);
   g_network_change_notifier_factory = factory;
@@ skipping 30 matching lines @@
 
 // static
 NetworkChangeNotifier::ConnectionType
 NetworkChangeNotifier::GetConnectionType() {
   return g_network_change_notifier ?
       g_network_change_notifier->GetCurrentConnectionType() :
       CONNECTION_UNKNOWN;
 }
 
 // static
+void NetworkChangeNotifier::GetDnsConfig(DnsConfig* config) {
+  if (!g_network_change_notifier) {
+    *config = DnsConfig();
+  } else {
+    g_network_change_notifier->network_state_->GetDnsConfig(config);
+  }
+}
+
+// static
 void NetworkChangeNotifier::NotifyDataReceived(const GURL& source) {
   if (!g_network_change_notifier)
     return;
   g_network_change_notifier->histogram_watcher_->NotifyDataReceived(source);
 }
 
 // static
 void NetworkChangeNotifier::InitHistogramWatcher() {
   if (!g_network_change_notifier)
     return;
-  g_network_change_notifier->histogram_watcher_->InitHistogramWatcher();
+  g_network_change_notifier->histogram_watcher_->Init();
 }
 
 #if defined(OS_LINUX)
 // static
 const internal::AddressTrackerLinux*
 NetworkChangeNotifier::GetAddressTracker() {
   return g_network_change_notifier ?
         g_network_change_notifier->GetAddressTrackerInternal() : NULL;
 }
 #endif
 
 // static
-bool NetworkChangeNotifier::IsWatchingDNS() {
-  if (!g_network_change_notifier)
-    return false;
-  base::AutoLock lock(g_network_change_notifier->watching_dns_lock_);
-  return g_network_change_notifier->watching_dns_;
-}
-
-// static
 NetworkChangeNotifier* NetworkChangeNotifier::CreateMock() {
   return new MockNetworkChangeNotifier();
 }
 
 void NetworkChangeNotifier::AddIPAddressObserver(IPAddressObserver* observer) {
   if (g_network_change_notifier)
     g_network_change_notifier->ip_address_observer_list_->AddObserver(observer);
 }
 
 void NetworkChangeNotifier::AddConnectionTypeObserver(
@@ skipping 37 matching lines @@
 NetworkChangeNotifier::NetworkChangeNotifier()
     : ip_address_observer_list_(
         new ObserverListThreadSafe<IPAddressObserver>(
             ObserverListBase<IPAddressObserver>::NOTIFY_EXISTING_ONLY)),
       connection_type_observer_list_(
         new ObserverListThreadSafe<ConnectionTypeObserver>(
             ObserverListBase<ConnectionTypeObserver>::NOTIFY_EXISTING_ONLY)),
       resolver_state_observer_list_(
         new ObserverListThreadSafe<DNSObserver>(
             ObserverListBase<DNSObserver>::NOTIFY_EXISTING_ONLY)),
-      watching_dns_(false) {
+      network_state_(new NetworkState()),
+      histogram_watcher_(new HistogramWatcher()) {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = this;
-  histogram_watcher_.reset(new HistogramWatcher());
 }
 
 #if defined(OS_LINUX)
 const internal::AddressTrackerLinux*
 NetworkChangeNotifier::GetAddressTrackerInternal() const {
   return NULL;
 }
 #endif
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfIPAddressChange() {
   if (g_network_change_notifier) {
     g_network_change_notifier->ip_address_observer_list_->Notify(
         &IPAddressObserver::OnIPAddressChanged);
   }
 }
 
 // static
-void NetworkChangeNotifier::NotifyObserversOfDNSChange(unsigned detail) {
+void NetworkChangeNotifier::NotifyObserversOfDNSChange() {
   if (g_network_change_notifier) {
-    {
-      base::AutoLock lock(g_network_change_notifier->watching_dns_lock_);
-      if (detail & NetworkChangeNotifier::CHANGE_DNS_WATCH_STARTED) {
-        g_network_change_notifier->watching_dns_ = true;
-      } else if (detail & NetworkChangeNotifier::CHANGE_DNS_WATCH_FAILED) {
-        g_network_change_notifier->watching_dns_ = false;
-      }
-      // Include detail that watch is off to spare the call to IsWatchingDNS.
-      if (!g_network_change_notifier->watching_dns_)
-        detail |= NetworkChangeNotifier::CHANGE_DNS_WATCH_FAILED;
-    }
-    DCHECK(!(detail & NetworkChangeNotifier::CHANGE_DNS_WATCH_FAILED) ||
-           !(detail & NetworkChangeNotifier::CHANGE_DNS_WATCH_STARTED));
     g_network_change_notifier->resolver_state_observer_list_->Notify(
-        &DNSObserver::OnDNSChanged, detail);
+        &DNSObserver::OnDNSChanged);
   }
 }
 
+// static
+void NetworkChangeNotifier::SetDnsConfig(const DnsConfig& config) {
+  if (!g_network_change_notifier)
+    return;
+  g_network_change_notifier->network_state_->SetDnsConfig(config);
+  NotifyObserversOfDNSChange();
+}
+
 void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChange() {
   if (g_network_change_notifier) {
     g_network_change_notifier->connection_type_observer_list_->Notify(
         &ConnectionTypeObserver::OnConnectionTypeChanged,
         GetConnectionType());
   }
 }
 
 NetworkChangeNotifier::DisableForTest::DisableForTest()
     : network_change_notifier_(g_network_change_notifier) {
   DCHECK(g_network_change_notifier);
   g_network_change_notifier = NULL;
 }
 
 NetworkChangeNotifier::DisableForTest::~DisableForTest() {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = network_change_notifier_;
 }
 
 }  // namespace net