Add comment about leaked FileDescriptorWatcher::Controller::Watcher.

base/files/file_descriptor_watcher_posix.cc

 // Copyright 2016 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_descriptor_watcher_posix.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local.h"
 
 namespace base {
 
 namespace {
 
 // MessageLoopForIO used to watch file descriptors for which callbacks are
 // registered from a given thread.
 LazyInstance<ThreadLocalPointer<MessageLoopForIO>>::Leaky
     tls_message_loop_for_io = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 FileDescriptorWatcher::Controller::~Controller() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
+
+  // Delete |watcher_| on the MessageLoopForIO.
+  //
+  // If the MessageLoopForIO is deleted before Watcher::StartWatching() runs,
+  // |watcher_| is leaked. If the MessageLoopForIO is deleted after
+  // Watcher::StartWatching() runs but before the DeleteSoon task runs,
+  // |watcher_| is deleted from Watcher::WillDestroyCurrentMessageLoop().
   message_loop_for_io_task_runner_->DeleteSoon(FROM_HERE, watcher_.release());
+
   // Since WeakPtrs are invalidated by the destructor, RunCallback() won't be
   // invoked after this returns.
 }
 
 class FileDescriptorWatcher::Controller::Watcher
     : public MessageLoopForIO::Watcher,
       public MessageLoop::DestructionObserver {
  public:
   Watcher(WeakPtr<Controller> controller, MessageLoopForIO::Mode mode, int fd);
   ~Watcher() override;
@@ skipping 149 matching lines @@
   return WrapUnique(new Controller(MessageLoopForIO::WATCH_READ, fd, callback));
 }
 
 std::unique_ptr<FileDescriptorWatcher::Controller>
 FileDescriptorWatcher::WatchWritable(int fd, const Closure& callback) {
   return WrapUnique(
       new Controller(MessageLoopForIO::WATCH_WRITE, fd, callback));
 }
 
 }  // namespace base