DevTools: use inotify to pick changes on the filesystem.

chrome/browser/devtools/devtools_file_watcher.cc

+// Copyright (c) 2015 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 "chrome/browser/devtools/devtools_file_watcher.h"
+
+#include "base/bind.h"
+#include "base/files/file_enumerator.h"
+#include "base/files/file_path.h"
+#include "base/files/file_path_watcher.h"
+#include "base/memory/ref_counted.h"
+#include "content/public/browser/browser_thread.h"
+
+using content::BrowserThread;
+
+// DevToolsFileWatcher::SharedFileWatcher --------------------------------------
+
+class DevToolsFileWatcher::SharedFileWatcher :
+    public base::RefCountedThreadSafe<SharedFileWatcher> {
+ public:
+  typedef base::Callback<void(const base::FilePath&, int)> WatchCallback;

[dgozman, 2015/11/04 20:11:29]

There is exactly same WatchCallback in DevToolsFileWatcher.

[pfeldman, 2015/11/05 00:18:42]

Done.

+  SharedFileWatcher();
+
+  void AddListener(DevToolsFileWatcher* watcher);
+  void RemoveListener(DevToolsFileWatcher* watcher);
+  void AddWatch(const base::FilePath& path);
+  void RemoveWatch(const base::FilePath& path);
+
+ private:
+  friend class base::RefCountedThreadSafe<
+      DevToolsFileWatcher::SharedFileWatcher>;
+  ~SharedFileWatcher();
+
+  void DirectoryChanged(const base::FilePath& path, bool error);
+
+  std::vector<DevToolsFileWatcher*> listeners_;
+  std::map<base::FilePath, base::FilePathWatcher> watchers_;
+  typedef std::map<base::FilePath, base::Time> FilePathTimesMap;

[dgozman, 2015/11/04 20:11:29]

using

[pfeldman, 2015/11/05 00:18:41]

Done.

+  FilePathTimesMap file_path_times_;
+};
+
+DevToolsFileWatcher::SharedFileWatcher::SharedFileWatcher() {
+  DevToolsFileWatcher::s_shared_watcher_ = this;
+}
+
+DevToolsFileWatcher::SharedFileWatcher::~SharedFileWatcher() {
+  DevToolsFileWatcher::s_shared_watcher_ = nullptr;
+}
+
+void DevToolsFileWatcher::SharedFileWatcher::AddListener(
+    DevToolsFileWatcher* watcher) {
+  listeners_.push_back(watcher);
+}
+
+void DevToolsFileWatcher::SharedFileWatcher::RemoveListener(
+    DevToolsFileWatcher* watcher) {
+  auto it = std::find(listeners_.begin(), listeners_.end(), watcher);
+  listeners_.erase(it);
+}
+
+void DevToolsFileWatcher::SharedFileWatcher::AddWatch(
+    const base::FilePath& path) {
+  if (watchers_.find(path) != watchers_.end())
+    return;
+  if (!base::FilePathWatcher::RecursiveWatchAvailable())
+    return;
+  bool success = watchers_[path].Watch(
+      path, true,
+      base::Bind(&SharedFileWatcher::DirectoryChanged, base::Unretained(this)));
+  if (!success)
+    return;
+
+  base::FileEnumerator enumerator(path, true, base::FileEnumerator::FILES);

[dgozman, 2015/11/04 20:11:29]

How does this perform on large workspaces?

[pfeldman, 2015/11/05 00:18:42]

MBP, SSD, 25K files
cold: 1532
hot: 210

All FILE thread, so seems reasonable.

+  base::FilePath file_path = enumerator.Next();
+  while (!file_path.empty()) {
+    base::FileEnumerator::FileInfo file_info = enumerator.GetInfo();
+    file_path_times_[file_path] = file_info.GetLastModifiedTime();
+    file_path = enumerator.Next();
+  }
+}
+
+void DevToolsFileWatcher::SharedFileWatcher::RemoveWatch(
+    const base::FilePath& path) {
+  watchers_.erase(path);
+}
+
+void DevToolsFileWatcher::SharedFileWatcher::DirectoryChanged(
+    const base::FilePath& path,
+    bool error) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::FileEnumerator enumerator(path, true, base::FileEnumerator::FILES);
+  base::FilePath file_path = enumerator.Next();
+  while (!file_path.empty()) {
+    base::FileEnumerator::FileInfo file_info = enumerator.GetInfo();
+    base::Time new_time = file_info.GetLastModifiedTime();
+    if (file_path_times_[file_path] != new_time) {
+      file_path_times_[file_path] = new_time;
+      for (auto watcher : listeners_) {
+        BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,

[dgozman, 2015/11/04 20:11:29]

I think we'll need a batch and progress indicator in frontend, while it re-reads
file contents. Imagine you do a "gclient sync", and DevTools become
unresponsive.

[pfeldman, 2015/11/05 00:18:42]

Let me instead
1) throttle it so that i was not re-enumerating the fs in browser
2) prevent checkContent from happening if content has not been loaded

+                                base::Bind(watcher->callback_, file_path,
+                                error));
+
+      }
+    }
+    file_path = enumerator.Next();
+  }
+}
+
+// static
+DevToolsFileWatcher::SharedFileWatcher*
+DevToolsFileWatcher::s_shared_watcher_ = nullptr;
+
+// DevToolsFileWatcher ---------------------------------------------------------
+
+DevToolsFileWatcher::DevToolsFileWatcher(const WatchCallback& callback)
+    : callback_(callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                          base::Bind(&DevToolsFileWatcher::InitSharedWatcher,
+                                     base::Unretained(this)));
+}
+
+DevToolsFileWatcher::~DevToolsFileWatcher() {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  shared_watcher_->RemoveListener(this);

[dgozman, 2015/11/04 20:11:29]

Why refcounting if you remove listener in destructor?

[pfeldman, 2015/11/05 00:18:42]

Done.

+}
+
+void DevToolsFileWatcher::InitSharedWatcher() {
+  if (!DevToolsFileWatcher::s_shared_watcher_)
+    new SharedFileWatcher();
+  shared_watcher_ = DevToolsFileWatcher::s_shared_watcher_;
+  shared_watcher_->AddListener(this);
+}
+
+void DevToolsFileWatcher::AddWatch(const base::FilePath& path) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  shared_watcher_->AddWatch(path);
+}
+
+void DevToolsFileWatcher::RemoveWatch(const base::FilePath& path) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  shared_watcher_->RemoveWatch(path);
+}