[net/dns] Isolate DnsConfigWatcher from DnsConfigService.

net/base/network_change_notifier_linux.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.
 //
 // This implementation of NetworkChangeNotifier's offline state detection
 // depends on D-Bus and NetworkManager, and is known to work on at least
 // GNOME version 2.30.  If D-Bus or NetworkManager are unavailable, this
 // implementation will always behave as if it is online.
 
 #include "net/base/network_change_notifier_linux.h"
 
 #include <errno.h>
+#include <resolv.h>
 #include <sys/socket.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/eintr_wrapper.h"
-#include "base/file_util.h"
-#include "base/files/file_path_watcher.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_change_notifier_netlink_linux.h"
-
-using ::base::files::FilePathWatcher;
+#include "net/dns/dns_config_watcher.h"
 
 namespace net {
 
 namespace {
 
 const int kInvalidSocket = -1;
 
 const char kNetworkManagerServiceName[] = "org.freedesktop.NetworkManager";
 const char kNetworkManagerPath[] = "/org/freedesktop/NetworkManager";
 const char kNetworkManagerInterface[] = "org.freedesktop.NetworkManager";
@@ skipping 12 matching lines @@
   NM_STATE_UNKNOWN = 0,
   NM_STATE_ASLEEP = 10,
   NM_STATE_DISCONNECTED = 20,
   NM_STATE_DISCONNECTING = 30,
   NM_STATE_CONNECTING = 40,
   NM_STATE_CONNECTED_LOCAL = 50,
   NM_STATE_CONNECTED_SITE = 60,
   NM_STATE_CONNECTED_GLOBAL = 70
 };
 
-class DNSWatchDelegate : public FilePathWatcher::Delegate {
- public:
-  explicit DNSWatchDelegate(const base::Closure& callback)
-      : callback_(callback) {}
-  virtual ~DNSWatchDelegate() {}
-  // FilePathWatcher::Delegate interface
-  virtual void OnFilePathChanged(const FilePath& path) OVERRIDE;
-  virtual void OnFilePathError(const FilePath& path) OVERRIDE;
- private:
-  base::Closure callback_;
-  DISALLOW_COPY_AND_ASSIGN(DNSWatchDelegate);
-};
-
-void DNSWatchDelegate::OnFilePathChanged(const FilePath& path) {
-  // Calls NetworkChangeNotifier::NotifyObserversOfDNSChange().
-  callback_.Run();
-}
-
-void DNSWatchDelegate::OnFilePathError(const FilePath& path) {
-  LOG(ERROR) << "DNSWatchDelegate::OnFilePathError for " << path.value();
-}
-
 }  // namespace
 
 // A wrapper around NetworkManager's D-Bus API.
 class NetworkManagerApi {
  public:
   NetworkManagerApi(const base::Closure& notification_callback, dbus::Bus* bus)
       : is_offline_(false),
         offline_state_initialized_(true /*manual_reset*/, false),
         notification_callback_(notification_callback),
         helper_thread_id_(base::kInvalidThreadId),
@@ skipping 165 matching lines @@
   return is_offline_;
 }
 
 class NetworkChangeNotifierLinux::Thread
     : public base::Thread, public MessageLoopForIO::Watcher {
  public:
   explicit Thread(dbus::Bus* bus);
   virtual ~Thread();
 
   // MessageLoopForIO::Watcher:
-  virtual void OnFileCanReadWithoutBlocking(int fd);
-  virtual void OnFileCanWriteWithoutBlocking(int /* fd */);
+  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
+  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE;
 
   // Plumbing for NetworkChangeNotifier::IsCurrentlyOffline.
   // Safe to call from any thread.
   bool IsCurrentlyOffline() {
     return network_manager_api_.IsCurrentlyOffline();
   }
 
  protected:
   // base::Thread
-  virtual void Init();
-  virtual void CleanUp();
+  virtual void Init() OVERRIDE;
+  virtual void CleanUp() OVERRIDE;
 
  private:
   // Starts listening for netlink messages.  Also handles the messages if there
   // are any available on the netlink socket.
   void ListenForNotifications();
 
   // Attempts to read from the netlink socket into |buf| of length |len|.
   // Returns the bytes read on synchronous success and ERR_IO_PENDING if the
   // recv() would block.  Otherwise, it returns a net error code.
   int ReadNotificationMessage(char* buf, size_t len);
 
   // The netlink socket descriptor.
   int netlink_fd_;
   MessageLoopForIO::FileDescriptorWatcher netlink_watcher_;
 
-  // Technically only needed for ChromeOS, but it's ugly to #ifdef out.
-  base::WeakPtrFactory<Thread> ptr_factory_;
-
-  // Used to watch for changes to /etc/resolv.conf and /etc/hosts.
-  scoped_ptr<base::files::FilePathWatcher> resolv_file_watcher_;
-  scoped_ptr<base::files::FilePathWatcher> hosts_file_watcher_;
-  scoped_refptr<DNSWatchDelegate> resolv_watcher_delegate_;
-  scoped_refptr<DNSWatchDelegate> hosts_watcher_delegate_;
-
   // Used to detect online/offline state changes.
   NetworkManagerApi network_manager_api_;
 
+  internal::DnsConfigWatcher dns_watcher_;
+
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 NetworkChangeNotifierLinux::Thread::Thread(dbus::Bus* bus)
     : base::Thread("NetworkChangeNotifier"),
       netlink_fd_(kInvalidSocket),
-      ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)),
       network_manager_api_(
           base::Bind(&NetworkChangeNotifier
                      ::NotifyObserversOfOnlineStateChange),
           bus) {
 }
 
 NetworkChangeNotifierLinux::Thread::~Thread() {
   DCHECK(!Thread::IsRunning());
 }
 
 void NetworkChangeNotifierLinux::Thread::Init() {
-  resolv_file_watcher_.reset(new FilePathWatcher);
-  hosts_file_watcher_.reset(new FilePathWatcher);
-  resolv_watcher_delegate_ = new DNSWatchDelegate(base::Bind(
-      &NetworkChangeNotifier::NotifyObserversOfDNSChange,
-      static_cast<unsigned>(CHANGE_DNS_SETTINGS)));
-  hosts_watcher_delegate_ = new DNSWatchDelegate(base::Bind(
-      &NetworkChangeNotifier::NotifyObserversOfDNSChange,
-      static_cast<unsigned>(CHANGE_DNS_HOSTS)));
-  if (!resolv_file_watcher_->Watch(
-          FilePath(FILE_PATH_LITERAL("/etc/resolv.conf")),
-          resolv_watcher_delegate_.get())) {
-    LOG(ERROR) << "Failed to setup watch for /etc/resolv.conf";
-  }
-  if (!hosts_file_watcher_->Watch(FilePath(FILE_PATH_LITERAL("/etc/hosts")),
-          hosts_watcher_delegate_.get())) {
-    LOG(ERROR) << "Failed to setup watch for /etc/hosts";
-  }
   netlink_fd_ = InitializeNetlinkSocket();
   if (netlink_fd_ < 0) {
     netlink_fd_ = kInvalidSocket;
     return;
   }
   ListenForNotifications();
 
   network_manager_api_.Init();
+
+  dns_watcher_.Init();
 }
 
 void NetworkChangeNotifierLinux::Thread::CleanUp() {
   if (netlink_fd_ != kInvalidSocket) {
     if (HANDLE_EINTR(close(netlink_fd_)) != 0)
       PLOG(ERROR) << "Failed to close socket";
     netlink_fd_ = kInvalidSocket;
     netlink_watcher_.StopWatchingFileDescriptor();
   }
-  // Kill watchers early to make sure they won't try to call
-  // into us via the delegate during destruction.
-  resolv_file_watcher_.reset();
-  hosts_file_watcher_.reset();
+  network_manager_api_.CleanUp();
 
-  network_manager_api_.CleanUp();
+  dns_watcher_.CleanUp();
 }
 
 void NetworkChangeNotifierLinux::Thread::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK_EQ(fd, netlink_fd_);
   ListenForNotifications();
 }
 
 void NetworkChangeNotifierLinux::Thread::OnFileCanWriteWithoutBlocking(
     int /* fd */) {
   NOTREACHED();
@@ skipping 58 matching lines @@
   // Stopping from here allows us to sanity- check that the notifier
   // thread shut down properly.
   notifier_thread_->Stop();
 }
 
 bool NetworkChangeNotifierLinux::IsCurrentlyOffline() const {
   return notifier_thread_->IsCurrentlyOffline();
 }
 
 }  // namespace net