Remove a unused parameter in the Linux FilePathWatcher implementation.

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 74 matching lines @@
 };
 
 class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate,
                             public MessageLoop::DestructionObserver {
  public:
   FilePathWatcherImpl();
 
   // Called for each event coming from the watch. |fired_watch| identifies the
   // watch that fired, |child| indicates what has changed, and is relative to
   // the currently watched path for |fired_watch|. The flag |created| is true if
-  // the object appears, and |is_directory| is set when the event refers to a
-  // directory.
+  // the object appears.
   void OnFilePathChanged(InotifyReader::Watch fired_watch,
                          const FilePath::StringType& child,
-                         bool created,
-                         bool is_directory);
+                         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,
                      FilePathWatcher::Delegate* delegate) 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
@@ skipping 173 matching lines @@
     return;
 
   FilePath::StringType child(event->len ? event->name : FILE_PATH_LITERAL(""));
   base::AutoLock auto_lock(lock_);
 
   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),
-                                  event->mask & IN_ISDIR);
+                                  event->mask & (IN_CREATE | IN_MOVED_TO));
   }
 }
 
 FilePathWatcherImpl::FilePathWatcherImpl()
     : delegate_(NULL) {
 }
 
-void FilePathWatcherImpl::OnFilePathChanged(
-    InotifyReader::Watch fired_watch,
-    const FilePath::StringType& child,
-    bool created,
-    bool is_directory) {
-
+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,
                    fired_watch,
                    child,
-                   created,
-                   is_directory));
+                   created));
     return;
   }
 
   DCHECK(MessageLoopForIO::current());
 
   // Find the entry in |watches_| that corresponds to |fired_watch|.
   WatchVector::const_iterator watch_entry(watches_.begin());
   for ( ; watch_entry != watches_.end(); ++watch_entry) {
     if (fired_watch == watch_entry->watch_) {
       // Check whether a path component of |target_| changed.
       bool change_on_target_path = child.empty() ||
           ((child == watch_entry->subdir_) && watch_entry->linkname_.empty()) ||
           (child == watch_entry->linkname_);
 
       // Check whether the change references |target_| or a direct child.
       DCHECK(watch_entry->subdir_.empty() ||
           (watch_entry + 1) != watches_.end());
       bool target_changed =
           (watch_entry->subdir_.empty() && (child == watch_entry->linkname_)) ||
           (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 is_directory here as changes to symlinks on the
-      // target path will not have is_directory set but as a result we
-      // may sometimes call UpdateWatches unnecessarily.
+      // 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_);
         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_);
         return;
       }
     }
   }
-
 }
 
 bool FilePathWatcherImpl::Watch(const FilePath& path,
                                 FilePathWatcher::Delegate* delegate) {
   DCHECK(target_.empty());
   DCHECK(MessageLoopForIO::current());
 
   set_message_loop(base::MessageLoopProxy::current());
   delegate_ = delegate;
   target_ = path;
@@ skipping 102 matching lines @@
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace files
 }  // namespace base