Update from https://crrev.com/309415

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 107 matching lines @@
   void Cancel() override;
 
   // Cleans up and stops observing the message_loop() thread.
   void CancelOnMessageLoopThread() 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.
   void WillDestroyCurrentMessageLoop() override;
 
-  // Inotify watches are installed for all directory components of |target_|. A
-  // WatchEntry instance holds the watch descriptor for a component and the
-  // subdirectory for that identifies the next component. If a symbolic link
-  // is being watched, the target of the link is also kept.
+  // Inotify watches are installed for all directory components of |target_|.
+  // A WatchEntry instance holds:
+  // - |watch|: the watch descriptor for a component.
+  // - |subdir|: the subdirectory that identifies the next component.
+  //   - For the last component, there is no next component, so it is empty.
+  // - |linkname|: the target of the symlink.
+  //   - Only if the target being watched is a symbolic link.
   struct WatchEntry {
     explicit WatchEntry(const FilePath::StringType& dirname)
         : watch(InotifyReader::kInvalidWatch),
           subdir(dirname) {}
 
     InotifyReader::Watch watch;
     FilePath::StringType subdir;
     FilePath::StringType linkname;
   };
   typedef std::vector<WatchEntry> WatchVector;
@@ skipping 232 matching lines @@
     if (fired_watch != watch_entry.watch)
       continue;
 
     // Check whether a path component of |target_| changed.
     bool change_on_target_path =
         child.empty() ||
         (child == watch_entry.linkname) ||
         (child == watch_entry.subdir);
 
     // Check if the change references |target_| or a direct child of |target_|.
-    bool is_watch_for_target = watch_entry.subdir.empty();
-    bool target_changed =
-        (is_watch_for_target && (child == watch_entry.linkname)) ||
-        (is_watch_for_target && watch_entry.linkname.empty()) ||
-        (watch_entry.subdir == child && watches_[i + 1].subdir.empty());
+    bool target_changed;
+    if (watch_entry.subdir.empty()) {
+      // The fired watch is for a WatchEntry without a subdir. Thus for a given
+      // |target_| = "/path/to/foo", this is for "foo". Here, check either:
+      // - the target has no symlink: it is the target and it changed.
+      // - the target has a symlink, and it matches |child|.
+      target_changed = (watch_entry.linkname.empty() ||
+                        child == watch_entry.linkname);
+    } else {
+      // The fired watch is for a WatchEntry with a subdir. Thus for a given
+      // |target_| = "/path/to/foo", this is for {"/", "/path", "/path/to"}.
+      // So we can safely access the next WatchEntry since we have not reached
+      // the end yet. Check |watch_entry| is for "/path/to", i.e. the next
+      // element is "foo".
+      bool next_watch_may_be_for_target = watches_[i + 1].subdir.empty();
+      if (next_watch_may_be_for_target) {
+        // The current |watch_entry| is for "/path/to", so check if the |child|
+        // that changed is "foo".
+        target_changed = watch_entry.subdir == child;
+      } else {
+        // The current |watch_entry| is not for "/path/to", so the next entry
+        // cannot be "foo". Thus |target_| has not changed.
+        target_changed = false;
+      }
+    }
 
     // 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 && (created || deleted) && !did_update) {
       UpdateWatches();
       did_update = true;
     }
@@ skipping 261 matching lines @@
   return watches_[watches_.size() - 1].subdir.empty();
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace base