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

base/files/file_path_watcher_kqueue.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 "base/files/file_path_watcher.h"
 
 #include <fcntl.h>
 #include <sys/event.h>
 #include <sys/param.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
+#include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/stringprintf.h"
 
 // On some platforms these are not defined.
 #if !defined(EV_RECEIPT)
 #define EV_RECEIPT 0
 #endif
 #if !defined(O_EVTONLY)
 #define O_EVTONLY O_RDONLY
@@ skipping 32 matching lines @@
 
   // MessageLoopForIO::Watcher overrides.
   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
   virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
 
   // MessageLoop::DestructionObserver overrides.
   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
 
   // FilePathWatcher::PlatformDelegate overrides.
   virtual bool Watch(const FilePath& path,
+                     bool recursive,
                      FilePathWatcher::Delegate* delegate) OVERRIDE;
   virtual void Cancel() OVERRIDE;
 
  protected:
   virtual ~FilePathWatcherImpl() {}
 
  private:
   class EventData {
    public:
     EventData(const FilePath& path, const FilePath::StringType& subdir)
@@ skipping 344 matching lines @@
 
 void FilePathWatcherImpl::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
 void FilePathWatcherImpl::WillDestroyCurrentMessageLoop() {
   CancelOnMessageLoopThread();
 }
 
 bool FilePathWatcherImpl::Watch(const FilePath& path,
+                                bool recursive,
                                 FilePathWatcher::Delegate* delegate) {
   DCHECK(MessageLoopForIO::current());
   DCHECK(target_.value().empty());  // Can only watch one path.
   DCHECK(delegate);
   DCHECK_EQ(kqueue_, -1);
 
+  if (recursive) {
+    NOTIMPLEMENTED();

[Mattias Nissler (ping if slow), 2012/11/21 09:28:48]

What's the effect of this at run time? I'd rather have something that CHECKS()
or at least DCHECKS() to avoid surprises.

[Lei Zhang, 2012/11/21 20:01:09]

I don't think we want to put in CHECKs. Let's say we are on "foo OS" and foo OS
does not provide any way to do recursive watches. If we had a CHECK here, the
higher level code that wants to call FilePathWatcher would need to know they
cannot do so on foo OS. That makes FilePathWatcher harder to use.

As is, calls to FilePathWatcher on foo OS would just return false, and the
caller can handle the false case, which it should be doing anyway.

file_path_watcher.h should have clear documentation that the recursive flag may
fail on platforms, so callers know what to expect.

[Mattias Nissler (ping if slow), 2012/11/22 08:51:34]

All right, you convinced me that returning false is probably good enough.

+    return false;
+  }
+
   delegate_ = delegate;
   target_ = path;
 
   MessageLoop::current()->AddDestructionObserver(this);
   io_message_loop_ = base::MessageLoopProxy::current();
 
   kqueue_ = kqueue();
   if (kqueue_ == -1) {
     DPLOG(ERROR) << "kqueue";
     return false;
@@ skipping 48 matching lines @@
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace files
 }  // namespace base