[net/dns] Watch configd notifications to detect DnsConfig changes on Mac.

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
+
 #ifndef _PATH_RESCONF  // Normally defined in <resolv.h>
 #define _PATH_RESCONF "/etc/resolv.conf"
 #endif
 
 namespace net {
 
 namespace {
 
-const FilePath::CharType* kFilePathConfig = FILE_PATH_LITERAL(_PATH_RESCONF);
 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)
+// Normally defined in dnsinfo.h in configd.

[Mark Mentovai, 2012/04/17 19:53:54]

You can do this:

extern "C" {

// From 10.7.3 configd-395.10/dnsinfo/dnsinfo.h
const char* dns_configuration_notify_key();

}  // extern "C"

Then you can call dns_configuration_notify_key() without hardcoding anything and
without <dnsinfo.h> being exposed. I like treating the Apple call as the
interface better than matching what they’ve hard-coded, even though both are
technically private.

[szym, 2012/04/17 20:14:31]

I wish this worked. Unfortunately, it won't link ("ld: symbol(s) not found").

[Mark Mentovai, 2012/04/17 20:22:20]

szym wrote:
I see, it’s marked “private_extern” in 10.5, which appears to be a bug based on
the AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER in its declaration, but that’s
life.

+const char* kDnsNotifyKey =

[Mark Mentovai, 2012/04/17 19:53:54]

If you’re sticking with a const char*, make it static or put it in an anonymous
namespace. There’s no reason to expose it beyond this file (even if in a
namespace called “internal”.)

+    "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
+const FilePath::CharType* kFilePathConfig = FILE_PATH_LITERAL(_PATH_RESCONF);

[Mark Mentovai, 2012/04/17 19:53:54]

This, too, can be static or in an anonymous namespace.

+
+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 FilePathWatcherWrapper()),
+    : config_watcher_(new ConfigWatcher()),
       hosts_watcher_(new FilePathWatcherWrapper()) {
   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(
-         FilePath(kFilePathConfig),
-         base::Bind(&DnsConfigServicePosix::OnConfigChanged,
-                    base::Unretained(this)))) {
+          base::Bind(&DnsConfigServicePosix::OnConfigChanged,
+                     base::Unretained(this)))) {
     OnConfigChanged(true);
   } else {
     OnConfigChanged(false);
   }
 
   if (hosts_watcher_->Watch(
-         FilePath(kFilePathHosts),
-         base::Bind(&DnsConfigServicePosix::OnHostsChanged,
-                    base::Unretained(this)))) {
+          FilePath(kFilePathHosts),
+          base::Bind(&DnsConfigServicePosix::OnHostsChanged,
+                     base::Unretained(this)))) {
     OnHostsChanged(true);
   } else {
     OnHostsChanged(false);
   }
 }
 
 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
@@ skipping 68 matching lines @@
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace internal
 
 // static
 scoped_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
   return scoped_ptr<DnsConfigService>(new internal::DnsConfigServicePosix());
 }
 
 }  // namespace net