Remove ref-counting from FilePathWatcher.

base/files/file_path_watcher_kqueue.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_kqueue.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/param.h>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 
 // On some platforms these are not defined.
 #if !defined(EV_RECEIPT)
 #define EV_RECEIPT 0
 #endif
 #if !defined(O_EVTONLY)
 #define O_EVTONLY O_RDONLY
 #endif
 
 namespace base {
 
 FilePathWatcherKQueue::FilePathWatcherKQueue() : kqueue_(-1) {}
 
-FilePathWatcherKQueue::~FilePathWatcherKQueue() {}
+FilePathWatcherKQueue::~FilePathWatcherKQueue() {
+  DCHECK(!task_runner() || task_runner()->RunsTasksOnCurrentThread());
+}
 
 void FilePathWatcherKQueue::ReleaseEvent(struct kevent& event) {
   CloseFileDescriptor(&event.ident);
   EventData* entry = EventDataForKevent(event);
   delete entry;
   event.udata = NULL;
 }
 
 int FilePathWatcherKQueue::EventsForPath(FilePath path, EventVector* events) {
   // Make sure that we are working with a clean slate.
@@ skipping 218 matching lines @@
                                   &responses[0], last_entry, NULL));
   if (!AreKeventValuesValid(&responses[0], count)) {
     // Calling Cancel() here to close any file descriptors that were opened.
     // This would happen in the destructor anyways, but FilePathWatchers tend to
     // be long lived, and if an error has occurred, there is no reason to waste
     // the file descriptors.
     Cancel();
     return false;
   }
 
-  // This creates an ownership cycle (|this| owns |kqueue_watch_controller_|
-  // which owns a callback which owns |this|). The cycle is broken when
-  // |kqueue_watch_controller_| is reset in Cancel().
+  // It's safe to use Unretained() because the watch is cancelled and the
+  // callback cannot be invoked after |kqueue_watch_controller_| (which is a
+  // member of |this|) has been deleted.
   kqueue_watch_controller_ = FileDescriptorWatcher::WatchReadable(
-      kqueue_, Bind(&FilePathWatcherKQueue::OnKQueueReadable, this));
+      kqueue_,
+      Bind(&FilePathWatcherKQueue::OnKQueueReadable, Unretained(this)));
+
   return true;
 }
 
 void FilePathWatcherKQueue::Cancel() {
   if (!task_runner()) {
     set_cancelled();
     return;
   }
 
   DCHECK(task_runner()->RunsTasksOnCurrentThread());
@@ skipping 76 matching lines @@
       Cancel();
     }
   }
 
   if (send_notification) {
     callback_.Run(target_, false);
   }
 }
 
 }  // namespace base