[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) {

[mmenke, 2012/05/16 16:18:03]

This function is identical on Windows and posix.  Think this CL is big enough as
is, but in a future CL, may be nice to have this function in the parent class. 
Then you can also mock out the readers and run tests by mimicking OnDNSChanged
events, and return configs via Gmock.

+  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