Only update watches when directories change.

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 <stddef.h>
 #include <string.h>
 #include <sys/inotify.h>
 #include <sys/ioctl.h>
 #include <sys/select.h>
+#include <sys/stat.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 
 namespace base {
 
 namespace {
 
 class FilePathWatcherImpl;
 
 // Singleton to manage all inotify watches.
 // TODO(tony): It would be nice if this wasn't a singleton.
@@ skipping 349 matching lines @@
     // 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 && deleted) ||
         (change_on_target_path && created && PathExists(target_))) {
-      if (!did_update) {
+      struct stat child_stat;
+      stat(target_.Append(watch_entry.subdir).Append(child).value().c_str(),
+           &child_stat);
+      if (!did_update && S_ISDIR(child_stat.st_mode)) {
         UpdateRecursiveWatches(fired_watch, is_dir);
         did_update = true;
       }
       callback_.Run(target_, false /* error */);
       return;
     }
   }
 
   if (ContainsKey(recursive_paths_by_watch_, fired_watch)) {
     if (!did_update)
@@ skipping 105 matching lines @@
   }
 
   // Check to see if this is a forced update or if some component of |target_|
   // has changed. For these cases, redo the watches for |target_| and below.
   if (!ContainsKey(recursive_paths_by_watch_, fired_watch)) {
     UpdateRecursiveWatchesForPath(target_);
     return;
   }
 
   // Underneath |target_|, only directory changes trigger watch updates.
   if (!is_dir)

[Shuhei Takahashi, 2016/09/05 10:48:09]

Hmm, is this check insufficient?

[dspaid, 2016/09/05 12:57:22]

Good catch.  It should be, but observations suggest it isn't.  I'll see if I can
track down why, as this would certainly be more elegant.

     return;
 
   const FilePath& changed_dir = recursive_paths_by_watch_[fired_watch];
 
   std::map<FilePath, InotifyReader::Watch>::iterator start_it =
       recursive_watches_by_path_.lower_bound(changed_dir);
   std::map<FilePath, InotifyReader::Watch>::iterator end_it = start_it;
   for (; end_it != recursive_watches_by_path_.end(); ++end_it) {
     const FilePath& cur_path = end_it->first;
     if (!changed_dir.IsParent(cur_path))
@@ skipping 109 matching lines @@
   return watches_.back().subdir.empty();
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace base