Implement recursive DirectoryWatcher watches on Linux

base/directory_watcher_inotify.cc

 // Copyright (c) 2009 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 "base/directory_watcher.h"
 
 #include <errno.h>
 #include <string.h>
 #include <sys/inotify.h>
 #include <sys/ioctl.h>
@@ skipping 70 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(InotifyReader);
 };
 
 class DirectoryWatcherImpl : public DirectoryWatcher::PlatformDelegate {
  public:
   typedef std::set<FilePath> FilePathSet;
 
   DirectoryWatcherImpl();
   ~DirectoryWatcherImpl();
 
-  void EnsureSetupFinished();
-
   // Called for each event coming from one of watches.
   void OnInotifyEvent(const inotify_event* event);
 
   // Callback for RegisterSubtreeWatchesTask.
   bool OnEnumeratedSubtree(const FilePathSet& paths);
 
   // Start watching |path| for changes and notify |delegate| on each change.
   // If |recursive| is true, watch entire subtree.
   // Returns true if watch for |path| has been added successfully. Watches
   // required for |recursive| are added on a background thread and have no
@@ skipping 10 matching lines @@
 
   // Delegate to notify upon changes.
   DirectoryWatcher::Delegate* delegate_;
 
   // Path we're watching (passed to delegate).
   FilePath root_path_;
 
   // Watch returned by InotifyReader.
   InotifyReader::Watch watch_;
 
-  // Set of watched inodes.
-  InodeSet inodes_watched_;
+  // Needed because inotify event-> name only provides name of the
+  // newly created/deleted file, without any path information.
+  // event->name = SubDir
+  // With this data structure we can get /tmp/DirectoryWatcherTest/SubDir.
+  base::hash_map<InotifyReader::Watch, FilePath> paths_;
 
-  // Keep track of registered watches.
-  WatchSet watches_;
+  typedef std::pair<ino_t, FilePath> InodeInfo;
+  base::hash_map<InotifyReader::Watch, InodeInfo> watches_;
 
   // Lock to protect inodes_watched_ and watches_.
   Lock lock_;
 
   // Flag set to true when recursively watching subtree.
   bool recursive_;
 
   // Loop where we post directory change notifications to.
   MessageLoop* loop_;
 
@@ skipping 157 matching lines @@
                                   IN_CREATE | IN_DELETE |
                                   IN_CLOSE_WRITE | IN_MOVE);
 
   if (watch == kInvalidWatch)
     return kInvalidWatch;
 
   if (paths_[watch].empty())
     paths_[watch] = path;  // We don't yet watch this path.
 
   watchers_[watch].insert(watcher);
-
   return watch;
 }
 
 bool InotifyReader::RemoveWatch(Watch watch,
                                 DirectoryWatcherImpl* watcher) {
   if (!valid_)
     return false;
 
   AutoLock auto_lock(lock_);
 
   if (paths_[watch].empty())
     return false;  // We don't recognize this watch.
 
   watchers_[watch].erase(watcher);
 
   if (watchers_[watch].empty()) {
     paths_.erase(watch);
     watchers_.erase(watch);
     return (inotify_rm_watch(inotify_fd_, watch) == 0);
   }
-
   return true;
 }
 
 void InotifyReader::OnInotifyEvent(const inotify_event* event) {
   if (event->mask & IN_IGNORED)
     return;
 
   WatcherSet watchers_to_notify;
   FilePath changed_path;
 
   {
     AutoLock auto_lock(lock_);
     changed_path = paths_[event->wd];
     watchers_to_notify.insert(watchers_[event->wd].begin(),
                               watchers_[event->wd].end());
   }
 
-  for (WatcherSet::iterator watcher = watchers_to_notify.begin();
+  for (WatcherSet::const_iterator watcher = watchers_to_notify.begin();
        watcher != watchers_to_notify.end();
        ++watcher) {
     (*watcher)->OnInotifyEvent(event);
   }
 }
 
 DirectoryWatcherImpl::DirectoryWatcherImpl()
     : watch_(InotifyReader::kInvalidWatch),
       recursive_setup_finished_(false, false) {
 }
 
 DirectoryWatcherImpl::~DirectoryWatcherImpl() {
   if (watch_ == InotifyReader::kInvalidWatch)
     return;
 
   if (recursive_)
     recursive_setup_finished_.Wait();
-  for (WatchSet::iterator watch = watches_.begin();
-       watch != watches_.end();
-       ++watch) {
-    Singleton<InotifyReader>::get()->RemoveWatch(*watch, this);
+
+  for (base::hash_map<InotifyReader::Watch, InodeInfo>::const_iterator it =
+       watches_.begin();
+       it != watches_.end();
+       ++it) {
+    Singleton<InotifyReader>::get()->RemoveWatch(it->first, this);
   }
   watches_.clear();
-  inodes_watched_.clear();
 }
 
 void DirectoryWatcherImpl::OnInotifyEvent(const inotify_event* event) {
   loop_->PostTask(FROM_HERE,
       new DirectoryWatcherImplNotifyTask(delegate_, root_path_));
 
   if (!(event->mask & IN_ISDIR))
     return;
 
+  FilePath path(watches_[event->wd].second);
+  path.Append(event->name);
   if (event->mask & IN_CREATE || event->mask & IN_MOVED_TO) {
-    // TODO(phajdan.jr): add watch for this new directory.
-    NOTIMPLEMENTED();
+    // Don't do anything, if not recursive watch;
+    if (!recursive_)
+      return;
+    if (event->mask & IN_MOVED_TO) {
+      // Don't do anything, if path is moved outside of root_path_.
+      if (path.value().compare(0, root_path_.value().length(),
+                               root_path_.value()))
+        return;
+    }
+    recursive_setup_finished_.Wait();
+    scoped_ptr<Task> subtree_task(new RegisterSubtreeWatchesTask(this, path));
+    subtree_task->Run();
   } else if (event->mask & IN_DELETE || event->mask & IN_MOVED_FROM) {
-    // TODO(phajdan.jr): remove our watch for this directory.
-    NOTIMPLEMENTED();
+    Singleton<InotifyReader>::get()->RemoveWatch(event->wd, this);
+
+    WatchSet delete_us;
+    AutoLock auto_lock(lock_);
+    watches_.erase(event->wd);
+    // Iterating on paths_ to find children wathces because inotify only fires
+    // an event for the parent directory, when a directory subtree is deleted.
+    for (base::hash_map<InotifyReader::Watch, InodeInfo>::const_iterator it =
+         watches_.begin();
+         it != watches_.end();
+         ++it) {
+      if (it->second.second.value().compare(0, path.value().length(),
+                                            path.value()))
+        continue;
+      delete_us.insert(it->first);
+      Singleton<InotifyReader>::get()->RemoveWatch(it->first, this);
+    }
+    for (WatchSet::const_iterator it = delete_us.begin();
+         it != delete_us.end(); ++it) {
+      watches_.erase(*it);
+    }
   }
 }
 
 bool DirectoryWatcherImpl::IsInodeWatched(ino_t inode) const {
-  return inodes_watched_.find(inode) != inodes_watched_.end();
+    for (base::hash_map<InotifyReader::Watch, InodeInfo>::const_iterator it =
+         watches_.begin();
+         it != watches_.end();
+         ++it) {
+      if (it->second.first == inode)
+        return true;
+    }
+  return false;
 }
 
 bool DirectoryWatcherImpl::OnEnumeratedSubtree(const FilePathSet& subtree) {
   DCHECK(recursive_);
 
   if (watch_ == InotifyReader::kInvalidWatch) {
     recursive_setup_finished_.Signal();
     return false;
   }
-
   bool success = true;
-  AutoLock auto_lock(lock_);
-  for (FilePathSet::iterator subdirectory = subtree.begin();
+  for (FilePathSet::const_iterator subdirectory = subtree.begin();
        subdirectory != subtree.end();
        ++subdirectory) {
     ino_t inode;
     if (!file_util::GetInode(*subdirectory, &inode)) {
       success = false;
       continue;
     }
     if (IsInodeWatched(inode))
       continue;
     InotifyReader::Watch watch =
       Singleton<InotifyReader>::get()->AddWatch(*subdirectory, this);
     if (watch != InotifyReader::kInvalidWatch) {
-      watches_.insert(watch);
-      inodes_watched_.insert(inode);
+      {
+        AutoLock auto_lock(lock_);
+        watches_[watch] = std::make_pair(inode, *subdirectory);
+      }
     }
   }
   recursive_setup_finished_.Signal();
   return success;
 }
 
 bool DirectoryWatcherImpl::Watch(const FilePath& path,
                                  DirectoryWatcher::Delegate* delegate,
                                  MessageLoop* backend_loop, bool recursive) {
-
   // Can only watch one path.
   DCHECK(watch_ == InotifyReader::kInvalidWatch);
 
   ino_t inode;
   if (!file_util::GetInode(path, &inode))
     return false;
 
   InotifyReader::Watch watch =
       Singleton<InotifyReader>::get()->AddWatch(path, this);
   if (watch == InotifyReader::kInvalidWatch)
     return false;
 
   delegate_ = delegate;
   recursive_ = recursive;
   root_path_ = path;
   watch_ = watch;
   loop_ = MessageLoop::current();
 
   {
     AutoLock auto_lock(lock_);
-    inodes_watched_.insert(inode);
-    watches_.insert(watch_);
+    watches_[watch_] = std::make_pair(inode, root_path_);
   }
 
   if (recursive_) {
     Task* subtree_task = new RegisterSubtreeWatchesTask(this, root_path_);
     if (backend_loop) {
       backend_loop->PostTask(FROM_HERE, subtree_task);
     } else {
       subtree_task->Run();
       delete subtree_task;
     }
   }
 
   return true;
 }
 
 }  // namespace
 
 DirectoryWatcher::DirectoryWatcher() {
   impl_ = new DirectoryWatcherImpl();
 }