Move base to DEPS

base/files/file_path_watcher_fsevents.cc

Index: base/files/file_path_watcher_fsevents.cc
diff --git a/base/files/file_path_watcher_fsevents.cc b/base/files/file_path_watcher_fsevents.cc
deleted file mode 100644
index da01c431bfe75e5323d2ce82531dc904ba3d0c95..0000000000000000000000000000000000000000
--- a/base/files/file_path_watcher_fsevents.cc
+++ /dev/null
@@ -1,284 +0,0 @@
-// Copyright 2014 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_fsevents.h"
-
-#include <list>
-
-#include "base/bind.h"
-#include "base/files/file_util.h"
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/mac/libdispatch_task_runner.h"
-#include "base/mac/scoped_cftyperef.h"
-#include "base/message_loop/message_loop.h"
-#include "base/thread_task_runner_handle.h"
-
-namespace base {
-
-namespace {
-
-// The latency parameter passed to FSEventsStreamCreate().
-const CFAbsoluteTime kEventLatencySeconds = 0.3;
-
-class FSEventsTaskRunner : public mac::LibDispatchTaskRunner {
- public:
-   FSEventsTaskRunner()
-       : mac::LibDispatchTaskRunner("org.chromium.FilePathWatcherFSEvents") {
-   }
-
- protected:
-  ~FSEventsTaskRunner() override {}
-};
-
-static LazyInstance<FSEventsTaskRunner>::Leaky g_task_runner =
-    LAZY_INSTANCE_INITIALIZER;
-
-// Resolve any symlinks in the path.
-FilePath ResolvePath(const FilePath& path) {
-  const unsigned kMaxLinksToResolve = 255;
-
-  std::vector<FilePath::StringType> component_vector;
-  path.GetComponents(&component_vector);
-  std::list<FilePath::StringType>
-      components(component_vector.begin(), component_vector.end());
-
-  FilePath result;
-  unsigned resolve_count = 0;
-  while (resolve_count < kMaxLinksToResolve && !components.empty()) {
-    FilePath component(*components.begin());
-    components.pop_front();
-
-    FilePath current;
-    if (component.IsAbsolute()) {
-      current = component;
-    } else {
-      current = result.Append(component);
-    }
-
-    FilePath target;
-    if (ReadSymbolicLink(current, &target)) {
-      if (target.IsAbsolute())
-        result.clear();
-      std::vector<FilePath::StringType> target_components;
-      target.GetComponents(&target_components);
-      components.insert(components.begin(), target_components.begin(),
-                        target_components.end());
-      resolve_count++;
-    } else {
-      result = current;
-    }
-  }
-
-  if (resolve_count >= kMaxLinksToResolve)
-    result.clear();
-  return result;
-}
-
-}  // namespace
-
-FilePathWatcherFSEvents::FilePathWatcherFSEvents() : fsevent_stream_(NULL) {
-}
-
-bool FilePathWatcherFSEvents::Watch(const FilePath& path,
-                                    bool recursive,
-                                    const FilePathWatcher::Callback& callback) {
-  DCHECK(MessageLoopForIO::current());
-  DCHECK(!callback.is_null());
-  DCHECK(callback_.is_null());
-
-  // This class could support non-recursive watches, but that is currently
-  // left to FilePathWatcherKQueue.
-  if (!recursive)
-    return false;
-
-  set_task_runner(ThreadTaskRunnerHandle::Get());
-  callback_ = callback;
-
-  FSEventStreamEventId start_event = FSEventsGetCurrentEventId();
-  g_task_runner.Get().PostTask(
-      FROM_HERE, Bind(&FilePathWatcherFSEvents::StartEventStream, this,
-                      start_event, path));
-  return true;
-}
-
-void FilePathWatcherFSEvents::Cancel() {
-  set_cancelled();
-  callback_.Reset();
-
-  // Switch to the dispatch queue thread to tear down the event stream.
-  g_task_runner.Get().PostTask(
-      FROM_HERE,
-      Bind(&FilePathWatcherFSEvents::CancelOnMessageLoopThread, this));
-}
-
-// static
-void FilePathWatcherFSEvents::FSEventsCallback(
-    ConstFSEventStreamRef stream,
-    void* event_watcher,
-    size_t num_events,
-    void* event_paths,
-    const FSEventStreamEventFlags flags[],
-    const FSEventStreamEventId event_ids[]) {
-  FilePathWatcherFSEvents* watcher =
-      reinterpret_cast<FilePathWatcherFSEvents*>(event_watcher);
-  DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
-
-  bool root_changed = watcher->ResolveTargetPath();
-  std::vector<FilePath> paths;
-  FSEventStreamEventId root_change_at = FSEventStreamGetLatestEventId(stream);
-  for (size_t i = 0; i < num_events; i++) {
-    if (flags[i] & kFSEventStreamEventFlagRootChanged)
-      root_changed = true;
-    if (event_ids[i])
-      root_change_at = std::min(root_change_at, event_ids[i]);
-    paths.push_back(FilePath(
-        reinterpret_cast<char**>(event_paths)[i]).StripTrailingSeparators());
-  }
-
-  // Reinitialize the event stream if we find changes to the root. This is
-  // necessary since FSEvents doesn't report any events for the subtree after
-  // the directory to be watched gets created.
-  if (root_changed) {
-    // Resetting the event stream from within the callback fails (FSEvents spews
-    // bad file descriptor errors), so post a task to do the reset.
-    g_task_runner.Get().PostTask(
-        FROM_HERE,
-        Bind(&FilePathWatcherFSEvents::UpdateEventStream, watcher,
-             root_change_at));
-  }
-
-  watcher->OnFilePathsChanged(paths);
-}
-
-FilePathWatcherFSEvents::~FilePathWatcherFSEvents() {
-  // This method may be called on either the libdispatch or task_runner()
-  // thread. Checking callback_ on the libdispatch thread here is safe because
-  // it is executing in a task posted by Cancel() which first reset callback_.
-  // PostTask forms a sufficient memory barrier to ensure that the value is
-  // consistent on the target thread.
-  DCHECK(callback_.is_null())
-      << "Cancel() must be called before FilePathWatcher is destroyed.";
-}
-
-void FilePathWatcherFSEvents::OnFilePathsChanged(
-    const std::vector<FilePath>& paths) {
-  DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
-  DCHECK(!resolved_target_.empty());
-  task_runner()->PostTask(
-      FROM_HERE, Bind(&FilePathWatcherFSEvents::DispatchEvents, this, paths,
-                      target_, resolved_target_));
-}
-
-void FilePathWatcherFSEvents::DispatchEvents(const std::vector<FilePath>& paths,
-                                             const FilePath& target,
-                                             const FilePath& resolved_target) {
-  DCHECK(task_runner()->RunsTasksOnCurrentThread());
-
-  // Don't issue callbacks after Cancel() has been called.
-  if (is_cancelled() || callback_.is_null()) {
-    return;
-  }
-
-  for (const FilePath& path : paths) {
-    if (resolved_target.IsParent(path) || resolved_target == path) {
-      callback_.Run(target, false);
-      return;
-    }
-  }
-}
-
-void FilePathWatcherFSEvents::CancelOnMessageLoopThread() {
-  // For all other implementations, the "message loop thread" is the IO thread,
-  // as returned by task_runner(). This implementation, however, needs to
-  // cancel pending work on the Dispatch Queue thread.
-  DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
-
-  if (fsevent_stream_) {
-    DestroyEventStream();
-    target_.clear();
-    resolved_target_.clear();
-  }
-}
-
-void FilePathWatcherFSEvents::UpdateEventStream(
-    FSEventStreamEventId start_event) {
-  DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
-
-  // It can happen that the watcher gets canceled while tasks that call this
-  // function are still in flight, so abort if this situation is detected.
-  if (resolved_target_.empty())
-    return;
-
-  if (fsevent_stream_)
-    DestroyEventStream();
-
-  ScopedCFTypeRef<CFStringRef> cf_path(CFStringCreateWithCString(
-      NULL, resolved_target_.value().c_str(), kCFStringEncodingMacHFS));
-  ScopedCFTypeRef<CFStringRef> cf_dir_path(CFStringCreateWithCString(
-      NULL, resolved_target_.DirName().value().c_str(),
-      kCFStringEncodingMacHFS));
-  CFStringRef paths_array[] = { cf_path.get(), cf_dir_path.get() };
-  ScopedCFTypeRef<CFArrayRef> watched_paths(CFArrayCreate(
-      NULL, reinterpret_cast<const void**>(paths_array), arraysize(paths_array),
-      &kCFTypeArrayCallBacks));
-
-  FSEventStreamContext context;
-  context.version = 0;
-  context.info = this;
-  context.retain = NULL;
-  context.release = NULL;
-  context.copyDescription = NULL;
-
-  fsevent_stream_ = FSEventStreamCreate(NULL, &FSEventsCallback, &context,
-                                        watched_paths,
-                                        start_event,
-                                        kEventLatencySeconds,
-                                        kFSEventStreamCreateFlagWatchRoot);
-  FSEventStreamSetDispatchQueue(fsevent_stream_,
-                                g_task_runner.Get().GetDispatchQueue());
-
-  if (!FSEventStreamStart(fsevent_stream_)) {
-    task_runner()->PostTask(
-        FROM_HERE, Bind(&FilePathWatcherFSEvents::ReportError, this, target_));
-  }
-}
-
-bool FilePathWatcherFSEvents::ResolveTargetPath() {
-  DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
-  FilePath resolved = ResolvePath(target_).StripTrailingSeparators();
-  bool changed = resolved != resolved_target_;
-  resolved_target_ = resolved;
-  if (resolved_target_.empty()) {
-    task_runner()->PostTask(
-        FROM_HERE, Bind(&FilePathWatcherFSEvents::ReportError, this, target_));
-  }
-  return changed;
-}
-
-void FilePathWatcherFSEvents::ReportError(const FilePath& target) {
-  DCHECK(task_runner()->RunsTasksOnCurrentThread());
-  if (!callback_.is_null()) {
-    callback_.Run(target, true);
-  }
-}
-
-void FilePathWatcherFSEvents::DestroyEventStream() {
-  FSEventStreamStop(fsevent_stream_);
-  FSEventStreamInvalidate(fsevent_stream_);
-  FSEventStreamRelease(fsevent_stream_);
-  fsevent_stream_ = NULL;
-}
-
-void FilePathWatcherFSEvents::StartEventStream(FSEventStreamEventId start_event,
-                                               const FilePath& path) {
-  DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
-  DCHECK(resolved_target_.empty());
-
-  target_ = path;
-  ResolveTargetPath();
-  UpdateEventStream(start_event);
-}
-
-}  // namespace base