Eliminate FilePathWatcher::Delegate.

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>
 
@@ skipping 48 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;
+                     const FilePathWatcher::Callback& callback) OVERRIDE;
   virtual void Cancel() OVERRIDE;
 
  protected:
   virtual ~FilePathWatcherImpl() {}
 
  private:
   class EventData {
    public:
     EventData(const FilePath& path, const FilePath::StringType& subdir)
         : path_(path), subdir_(subdir) { }
@@ skipping 54 matching lines @@
     return event.ident != static_cast<uintptr_t>(-1);
   }
 
   static EventData* EventDataForKevent(const struct kevent& event) {
     return reinterpret_cast<EventData*>(event.udata);
   }
 
   EventVector events_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
   MessageLoopForIO::FileDescriptorWatcher kqueue_watcher_;
-  scoped_refptr<FilePathWatcher::Delegate> delegate_;
+  FilePathWatcher::Callback callback_;
   FilePath target_;
   int kqueue_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePathWatcherImpl);
 };
 
 void FilePathWatcherImpl::ReleaseEvent(struct kevent& event) {
   CloseFileDescriptor(reinterpret_cast<int*>(&event.ident));
   EventData* entry = EventDataForKevent(event);
   delete entry;
@@ skipping 202 matching lines @@
   // them in |updates|. |count| will contain the number of updates that have
   // occurred.
   EventVector updates(events_.size());
   struct timespec timeout = {0, 0};
   int count = HANDLE_EINTR(kevent(kqueue_, NULL, 0, &updates[0], updates.size(),
                                   &timeout));
 
   // Error values are stored within updates, so check to make sure that no
   // errors occurred.
   if (!AreKeventValuesValid(&updates[0], count)) {
-    delegate_->OnFilePathError(target_);
+    callback_.Run(target_, true /* error */);
     Cancel();
     return;
   }
 
   bool update_watches = false;
   bool send_notification = false;
 
   // Iterate through each of the updates and react to them.
   for (int i = 0; i < count; ++i) {
     // Find our kevent record that matches the update notification.
@@ skipping 26 matching lines @@
       HandleDeleteOrMoveChange(event, &target_file_affected, &update_watches);
     }
     if ((updates[i].fflags & NOTE_WRITE) && !target_file_affected) {
       HandleCreateItemChange(event, &target_file_affected, &update_watches);
     }
     send_notification |= target_file_affected;
   }
 
   if (update_watches) {
     if (!UpdateWatches(&send_notification)) {
-      delegate_->OnFilePathError(target_);
+      callback_.Run(target_, true /* error */);
       Cancel();
     }
   }
 
   if (send_notification) {
-    delegate_->OnFilePathChanged(target_);
+    callback_.Run(target_, false);
   }
 }
 
 void FilePathWatcherImpl::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
 void FilePathWatcherImpl::WillDestroyCurrentMessageLoop() {
   CancelOnMessageLoopThread();
 }
 
 bool FilePathWatcherImpl::Watch(const FilePath& path,
                                 bool recursive,
-                                FilePathWatcher::Delegate* delegate) {
+                                const FilePathWatcher::Callback& callback) {
   DCHECK(MessageLoopForIO::current());
   DCHECK(target_.value().empty());  // Can only watch one path.
-  DCHECK(delegate);
+  DCHECK(!callback.is_null());
   DCHECK_EQ(kqueue_, -1);
 
   if (recursive) {
     // Recursive watch is not supported on this platform.
     NOTIMPLEMENTED();
     return false;
   }
 
-  delegate_ = delegate;
+  callback_ = callback;
   target_ = path;
 
   MessageLoop::current()->AddDestructionObserver(this);
   io_message_loop_ = base::MessageLoopProxy::current();
 
   kqueue_ = kqueue();
   if (kqueue_ == -1) {
     DPLOG(ERROR) << "kqueue";
     return false;
   }
@@ skipping 35 matching lines @@
 void FilePathWatcherImpl::CancelOnMessageLoopThread() {
   DCHECK(MessageLoopForIO::current());
   if (!is_cancelled()) {
     set_cancelled();
     kqueue_watcher_.StopWatchingFileDescriptor();
     CloseFileDescriptor(&kqueue_);
     std::for_each(events_.begin(), events_.end(), ReleaseEvent);
     events_.clear();
     io_message_loop_ = NULL;
     MessageLoop::current()->RemoveDestructionObserver(this);
-    delegate_ = NULL;
+    callback_.Reset();
   }
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace files
 }  // namespace base