FilePathWatcher::Watch() - Listen for sub directory changes.

base/files/file_path_watcher_win.cc

 // Copyright (c) 2011 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/files/file_path_watcher.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop_proxy.h"
 #include "base/time.h"
 #include "base/win/object_watcher.h"
 
 namespace base {
 namespace files {
 
 namespace {
 
 class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate,
                             public base::win::ObjectWatcher::Delegate,
                             public MessageLoop::DestructionObserver {
  public:
-  FilePathWatcherImpl() : delegate_(NULL), handle_(INVALID_HANDLE_VALUE) {}
+  FilePathWatcherImpl()
+      : delegate_(NULL),
+        handle_(INVALID_HANDLE_VALUE),
+        recursive_watch_(false) {}
 
   // FilePathWatcher::PlatformDelegate overrides.
   virtual bool Watch(const FilePath& path,
+                     bool recursive,
                      FilePathWatcher::Delegate* delegate) OVERRIDE;
   virtual void Cancel() OVERRIDE;
 
   // Deletion of the FilePathWatcher will call Cancel() to dispose of this
   // object in the right thread. This also observes destruction of the required
   // cleanup thread, in case it quits before Cancel() is called.
   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
 
   // Callback from MessageLoopForIO.
   virtual void OnObjectSignaled(HANDLE object);
 
  private:
   virtual ~FilePathWatcherImpl() {}
 
-  // Setup a watch handle for directory |dir|. Returns true if no fatal error
-  // occurs. |handle| will receive the handle value if |dir| is watchable,
-  // otherwise INVALID_HANDLE_VALUE.
-  static bool SetupWatchHandle(const FilePath& dir, HANDLE* handle)
-      WARN_UNUSED_RESULT;
+  // Setup a watch handle for directory |dir|. Set |recursive| to true to watch
+  // the directory sub trees. Returns true if no fatal error occurs. |handle|
+  // will receive the handle value if |dir| is watchable, otherwise
+  // INVALID_HANDLE_VALUE.
+  static bool SetupWatchHandle(const FilePath& dir,
+                               bool recursive,
+                               HANDLE* handle) WARN_UNUSED_RESULT;
 
   // (Re-)Initialize the watch handle.
   bool UpdateWatch() WARN_UNUSED_RESULT;
 
   // Destroy the watch handle.
   void DestroyWatch();
 
   // Cleans up and stops observing the |message_loop_| thread.
   void CancelOnMessageLoopThread() OVERRIDE;
 
   // Delegate to notify upon changes.
   scoped_refptr<FilePathWatcher::Delegate> delegate_;
 
   // Path we're supposed to watch (passed to delegate).
   FilePath target_;
 
   // Handle for FindFirstChangeNotification.
   HANDLE handle_;
 
   // ObjectWatcher to watch handle_ for events.
   base::win::ObjectWatcher watcher_;
 
+  // Set to true to watch the sub trees of the specified directory file path.
+  bool recursive_watch_;

[Lei Zhang, 2012/12/03 21:44:39]

Can you just pass this to UpdateWatch() and SetupWatchHandle()? Unlike the other
variables, it doesn't seemed to be used anywhere else like in
OnObjectSignaled().

[kmadhusu, 2012/12/03 22:54:57]

UpdateWatch() is also called from FilePathWatcherImpl::OnObjectSignaled. That is
the reason, I didn't pass recursive_watch as param from
Watch()->UpdateWatch()->SetupWatchHandle().

+
   // Keep track of the last modified time of the file.  We use nulltime
   // to represent the file not existing.
   base::Time last_modified_;
 
   // The time at which we processed the first notification with the
   // |last_modified_| time stamp.
   base::Time first_notification_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePathWatcherImpl);
 };
 
 bool FilePathWatcherImpl::Watch(const FilePath& path,
+                                bool recursive,
                                 FilePathWatcher::Delegate* delegate) {
   DCHECK(target_.value().empty());  // Can only watch one path.
 
   set_message_loop(base::MessageLoopProxy::current());
   delegate_ = delegate;
   target_ = path;
+  recursive_watch_ = recursive;
   MessageLoop::current()->AddDestructionObserver(this);
 
   if (!UpdateWatch())
     return false;
 
   watcher_.StartWatching(handle_, this);
 
   return true;
 }
 
@@ skipping 74 matching lines @@
     delegate_->OnFilePathChanged(target_);
   }
 
   // The watch may have been cancelled by the callback.
   if (handle_ != INVALID_HANDLE_VALUE)
     watcher_.StartWatching(handle_, this);
 }
 
 // static
 bool FilePathWatcherImpl::SetupWatchHandle(const FilePath& dir,
+                                           bool recursive,
                                            HANDLE* handle) {
   *handle = FindFirstChangeNotification(
       dir.value().c_str(),
-      false,  // Don't watch subtrees
+      recursive,
       FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_SIZE |
       FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_DIR_NAME |
       FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SECURITY);
   if (*handle != INVALID_HANDLE_VALUE) {
     // Make sure the handle we got points to an existing directory. It seems
-    // that windows sometimes hands out watches to direectories that are
+    // that windows sometimes hands out watches to directories that are
     // about to go away, but doesn't sent notifications if that happens.
     if (!file_util::DirectoryExists(dir)) {
       FindCloseChangeNotification(*handle);
       *handle = INVALID_HANDLE_VALUE;
     }
     return true;
   }
 
   // If FindFirstChangeNotification failed because the target directory
   // doesn't exist, access is denied (happens if the file is already gone but
@@ skipping 23 matching lines @@
     last_modified_ = file_info.last_modified;
     first_notification_ = base::Time::Now();
   }
 
   // Start at the target and walk up the directory chain until we succesfully
   // create a watch handle in |handle_|. |child_dirs| keeps a stack of child
   // directories stripped from target, in reverse order.
   std::vector<FilePath> child_dirs;
   FilePath watched_path(target_);
   while (true) {
-    if (!SetupWatchHandle(watched_path, &handle_))
+    if (!SetupWatchHandle(watched_path, recursive_watch_, &handle_))
       return false;
 
     // Break if a valid handle is returned. Try the parent directory otherwise.
     if (handle_ != INVALID_HANDLE_VALUE)
       break;
 
     // Abort if we hit the root directory.
     child_dirs.push_back(watched_path.BaseName());
     FilePath parent(watched_path.DirName());
     if (parent == watched_path) {
       DLOG(ERROR) << "Reached the root directory";
       return false;
     }
     watched_path = parent;
   }
 
   // At this point, handle_ is valid. However, the bottom-up search that the
   // above code performs races against directory creation. So try to walk back
   // down and see whether any children appeared in the mean time.
   while (!child_dirs.empty()) {
     watched_path = watched_path.Append(child_dirs.back());
     child_dirs.pop_back();
     HANDLE temp_handle = INVALID_HANDLE_VALUE;
-    if (!SetupWatchHandle(watched_path, &temp_handle))
+    if (!SetupWatchHandle(watched_path, recursive_watch_, &temp_handle))
       return false;
     if (temp_handle == INVALID_HANDLE_VALUE)
       break;
     FindCloseChangeNotification(handle_);
     handle_ = temp_handle;
   }
 
   return true;
 }
 
 void FilePathWatcherImpl::DestroyWatch() {
   watcher_.StopWatching();
   FindCloseChangeNotification(handle_);
   handle_ = INVALID_HANDLE_VALUE;
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace files
 }  // namespace base