Eliminate FilePathWatcher::Delegate.

base/files/file_path_watcher_linux.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 <errno.h>
 #include <string.h>
 #include <sys/inotify.h>
 #include <sys/ioctl.h>
@@ skipping 83 matching lines @@
   // the currently watched path for |fired_watch|. The flag |created| is true if
   // the object appears.
   void OnFilePathChanged(InotifyReader::Watch fired_watch,
                          const FilePath::StringType& child,
                          bool created);
 
   // Start watching |path| for changes and notify |delegate| on each change.
   // Returns true if watch for |path| has been added successfully.
   virtual bool Watch(const FilePath& path,
                      bool recursive,
-                     FilePathWatcher::Delegate* delegate) OVERRIDE;
+                     const FilePathWatcher::Callback& callback) OVERRIDE;
 
   // Cancel the watch. This unregisters the instance with InotifyReader.
   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;
 
  protected:
@@ skipping 15 matching lines @@
     InotifyReader::Watch watch_;
     FilePath::StringType subdir_;
     FilePath::StringType linkname_;
   };
   typedef std::vector<WatchEntry> WatchVector;
 
   // Reconfigure to watch for the most specific parent directory of |target_|
   // that exists. Updates |watched_path_|. Returns true on success.
   bool UpdateWatches() WARN_UNUSED_RESULT;
 
-  // Delegate to notify upon changes.
-  scoped_refptr<FilePathWatcher::Delegate> delegate_;
+  // Callback to notify upon changes.
+  FilePathWatcher::Callback callback_;
 
   // The file or directory we're supposed to watch.
   FilePath target_;
 
   // The vector of watches and next component names for all path components,
   // starting at the root directory. The last entry corresponds to the watch for
   // |target_| and always stores an empty next component name in |subdir_|.
   WatchVector watches_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePathWatcherImpl);
@@ skipping 136 matching lines @@
 
   for (WatcherSet::iterator watcher = watchers_[event->wd].begin();
        watcher != watchers_[event->wd].end();
        ++watcher) {
     (*watcher)->OnFilePathChanged(event->wd,
                                   child,
                                   event->mask & (IN_CREATE | IN_MOVED_TO));
   }
 }
 
-FilePathWatcherImpl::FilePathWatcherImpl()
-    : delegate_(NULL) {
+FilePathWatcherImpl::FilePathWatcherImpl() {
 }
 
 void FilePathWatcherImpl::OnFilePathChanged(InotifyReader::Watch fired_watch,
                                             const FilePath::StringType& child,
                                             bool created) {
   if (!message_loop()->BelongsToCurrentThread()) {
     // Switch to message_loop_ to access watches_ safely.
     message_loop()->PostTask(FROM_HERE,
         base::Bind(&FilePathWatcherImpl::OnFilePathChanged,
                    this,
@@ skipping 22 matching lines @@
           (watch_entry->subdir_.empty() && watch_entry->linkname_.empty()) ||
           (watch_entry->subdir_ == child && (watch_entry + 1)->subdir_.empty());
 
       // Update watches if a directory component of the |target_| path
       // (dis)appears. Note that we don't add the additional restriction
       // of checking the event mask to see if it is for a directory here
       // as changes to symlinks on the target path will not have
       // IN_ISDIR set in the event masks. As a result we may sometimes
       // call UpdateWatches() unnecessarily.
       if (change_on_target_path && !UpdateWatches()) {
-        delegate_->OnFilePathError(target_);
+        callback_.Run(target_, true /* error */);
         return;
       }
 
       // Report the following events:
       //  - The target or a direct child of the target got changed (in case the
       //    watched path refers to a directory).
       //  - One of the parent directories got moved or deleted, since the target
       //    disappears in this case.
       //  - One of the parent directories appears. The event corresponding to
       //    the target appearing might have been missed in this case, so
       //    recheck.
       if (target_changed ||
           (change_on_target_path && !created) ||
           (change_on_target_path && file_util::PathExists(target_))) {
-        delegate_->OnFilePathChanged(target_);
+        callback_.Run(target_, false);
         return;
       }
     }
   }
 }
 
 bool FilePathWatcherImpl::Watch(const FilePath& path,
                                 bool recursive,
-                                FilePathWatcher::Delegate* delegate) {
+                                const FilePathWatcher::Callback& callback) {
   DCHECK(target_.empty());
   DCHECK(MessageLoopForIO::current());
   if (recursive) {
     // Recursive watch is not supported on this platform.
     NOTIMPLEMENTED();
     return false;
   }
 
   set_message_loop(base::MessageLoopProxy::current());
-  delegate_ = delegate;
+  callback_ = callback;
   target_ = path;
   MessageLoop::current()->AddDestructionObserver(this);
 
   std::vector<FilePath::StringType> comps;
   target_.GetComponents(&comps);
   DCHECK(!comps.empty());
   std::vector<FilePath::StringType>::const_iterator comp = comps.begin();
   for (++comp; comp != comps.end(); ++comp)
     watches_.push_back(WatchEntry(InotifyReader::kInvalidWatch, *comp));
 
   watches_.push_back(WatchEntry(InotifyReader::kInvalidWatch,
                                 FilePath::StringType()));
   return UpdateWatches();
 }
 
 void FilePathWatcherImpl::Cancel() {
-  if (!delegate_) {
+  if (callback_.is_null()) {
     // Watch was never called, or the |message_loop_| thread is already gone.
     set_cancelled();
     return;
   }
 
   // Switch to the message_loop_ if necessary so we can access |watches_|.
   if (!message_loop()->BelongsToCurrentThread()) {
     message_loop()->PostTask(FROM_HERE,
                              base::Bind(&FilePathWatcher::CancelWatch,
                                         make_scoped_refptr(this)));
   } else {
     CancelOnMessageLoopThread();
   }
 }
 
 void FilePathWatcherImpl::CancelOnMessageLoopThread() {
   if (!is_cancelled())
     set_cancelled();
 
-  if (delegate_) {
+  if (!callback_.is_null()) {
     MessageLoop::current()->RemoveDestructionObserver(this);
-    delegate_ = NULL;
+    callback_.Reset();
   }
 
   for (WatchVector::iterator watch_entry(watches_.begin());
        watch_entry != watches_.end(); ++watch_entry) {
     if (watch_entry->watch_ != InotifyReader::kInvalidWatch)
       g_inotify_reader.Get().RemoveWatch(watch_entry->watch_, this);
   }
   watches_.clear();
   target_.clear();
 }
@@ skipping 55 matching lines @@
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace files
 }  // namespace base