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) {
+    // Recursive watch is not supported on this platform.
+    NOTIMPLEMENTED();
+    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