[net/dns] Isolate DnsConfigWatcher from DnsConfigService.

net/dns/dns_config_service_posix.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/dns_config_service_posix.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_util.h"
 #include "net/dns/file_path_watcher_wrapper.h"
 #include "net/dns/serial_worker.h"
 
-#if defined(OS_MACOSX)
-#include "net/dns/notify_watcher_mac.h"
-#endif
+namespace net {
+
+namespace {
 
 #ifndef _PATH_RESCONF  // Normally defined in <resolv.h>
 #define _PATH_RESCONF "/etc/resolv.conf"
 #endif
 
-namespace net {
-
-namespace {
-
 const FilePath::CharType* kFilePathHosts = FILE_PATH_LITERAL("/etc/hosts");
 
 // A SerialWorker that uses libresolv to initialize res_state and converts
 // it to DnsConfig.
 class ConfigReader : public SerialWorker {
  public:
   typedef base::Callback<void(const DnsConfig& config)> CallbackType;
   explicit ConfigReader(const CallbackType& callback)
       : callback_(callback),
         success_(false) {}
@@ skipping 37 matching lines @@
   CallbackType callback_;
   // Written in DoWork, read in OnWorkFinished, no locking necessary.
   DnsConfig dns_config_;
   bool success_;
 };
 
 }  // namespace
 
 namespace internal {
 
-#if defined(OS_MACOSX)
-// From 10.7.3 configd-395.10/dnsinfo/dnsinfo.h
-static const char* kDnsNotifyKey =
-    "com.apple.system.SystemConfiguration.dns_configuration";
-
-class DnsConfigServicePosix::ConfigWatcher : public NotifyWatcherMac {
- public:
-  bool Watch(const base::Callback<void(bool succeeded)>& callback) {
-    return NotifyWatcherMac::Watch(kDnsNotifyKey, callback);
-  }
-};
-#else
-static const FilePath::CharType* kFilePathConfig =
-    FILE_PATH_LITERAL(_PATH_RESCONF);
-
-class DnsConfigServicePosix::ConfigWatcher : public FilePathWatcherWrapper {
- public:
-  bool Watch(const base::Callback<void(bool succeeded)>& callback) {
-    return FilePathWatcherWrapper::Watch(FilePath(kFilePathConfig), callback);
-  }
-};
-#endif
-
-DnsConfigServicePosix::DnsConfigServicePosix()
-    : config_watcher_(new ConfigWatcher()),
-      hosts_watcher_(new FilePathWatcherWrapper()) {
+DnsConfigServicePosix::DnsConfigServicePosix() {
   config_reader_ = new ConfigReader(
       base::Bind(&DnsConfigServicePosix::OnConfigRead,
                  base::Unretained(this)));
   hosts_reader_ = new DnsHostsReader(
       FilePath(kFilePathHosts),
       base::Bind(&DnsConfigServicePosix::OnHostsRead,
                  base::Unretained(this)));
 }
 
 DnsConfigServicePosix::~DnsConfigServicePosix() {
   config_reader_->Cancel();
   hosts_reader_->Cancel();
 }
 
-void DnsConfigServicePosix::Watch(const CallbackType& callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!callback.is_null());
-  set_callback(callback);
-
-  // Even if watchers fail, we keep the other one as it provides useful signals.
-  if (config_watcher_->Watch(
-          base::Bind(&DnsConfigServicePosix::OnConfigChanged,
-                     base::Unretained(this)))) {
-    OnConfigChanged(true);
-  } else {
-    OnConfigChanged(false);
+void DnsConfigServicePosix::OnDNSChanged(unsigned detail) {
+  if (detail & NetworkChangeNotifier::CHANGE_DNS_WATCH_FAILED) {
+    InvalidateConfig();
+    InvalidateHosts();
+    // We don't trust a config that we cannot watch in the future.
+    config_reader_->Cancel();
+    hosts_reader_->Cancel();
+    return;
   }
-
-  if (hosts_watcher_->Watch(
-          FilePath(kFilePathHosts),
-          base::Bind(&DnsConfigServicePosix::OnHostsChanged,
-                     base::Unretained(this)))) {
-    OnHostsChanged(true);
-  } else {
-    OnHostsChanged(false);
+  if (detail & NetworkChangeNotifier::CHANGE_DNS_WATCH_STARTED)
+    detail = ~0;  // Assume everything changed.
+  if (detail & NetworkChangeNotifier::CHANGE_DNS_SETTINGS) {
+    InvalidateConfig();
+    config_reader_->WorkNow();
+  }
+  if (detail & NetworkChangeNotifier::CHANGE_DNS_HOSTS) {
+    InvalidateHosts();
+    hosts_reader_->WorkNow();
   }
 }
 
-void DnsConfigServicePosix::OnConfigChanged(bool watch_succeeded) {
-  InvalidateConfig();
-  // We don't trust a config that we cannot watch in the future.
-  // TODO(szym): re-start watcher if that makes sense. http://crbug.com/116139
-  if (watch_succeeded)
-    config_reader_->WorkNow();
-  else
-    LOG(ERROR) << "Failed to watch DNS config";
-}
-
-void DnsConfigServicePosix::OnHostsChanged(bool watch_succeeded) {
-  InvalidateHosts();
-  if (watch_succeeded)
-    hosts_reader_->WorkNow();
-  else
-    LOG(ERROR) << "Failed to watch DNS hosts";
-}
-
 #if !defined(OS_ANDROID)
 bool ConvertResStateToDnsConfig(const struct __res_state& res,
                                 DnsConfig* dns_config) {
   CHECK(dns_config != NULL);
   DCHECK(res.options & RES_INIT);
 
   dns_config->nameservers.clear();
 
 #if defined(OS_MACOSX) || defined(OS_FREEBSD)
   union res_sockaddr_union addresses[MAXNS];
@@ skipping 65 matching lines @@
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace internal
 
 // static
 scoped_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
   return scoped_ptr<DnsConfigService>(new internal::DnsConfigServicePosix());
 }
 
 }  // namespace net