Use the location where FileDescriptorWatcher is created to track the libevent handlers

base/message_loop/message_pump_libevent_unittest.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/message_loop/message_pump_libevent.h"
 
 #include <unistd.h>
 
 #include <memory>
 
@@ skipping 70 matching lines @@
 
 // Test to make sure that we catch calling WatchFileDescriptor off of the
 // wrong thread.
 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
 // Flaky on Chrome OS and Linux: crbug.com/138845.
 #define MAYBE_TestWatchingFromBadThread DISABLED_TestWatchingFromBadThread
 #else
 #define MAYBE_TestWatchingFromBadThread TestWatchingFromBadThread
 #endif
 TEST_F(MessagePumpLibeventTest, MAYBE_TestWatchingFromBadThread) {
-  MessagePumpLibevent::FileDescriptorWatcher watcher;
+  MessagePumpLibevent::FileDescriptorWatcher watcher(FROM_HERE);
   StupidWatcher delegate;
 
   ASSERT_DCHECK_DEATH(
       io_loop()->WatchFileDescriptor(STDOUT_FILENO, false,
                                      MessageLoopForIO::WATCH_READ, &watcher,
                                      &delegate));
 }
 
 TEST_F(MessagePumpLibeventTest, QuitOutsideOfRun) {
   std::unique_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
@@ skipping 28 matching lines @@
   void OnFileCanWriteWithoutBlocking(int /* fd */) override {
     DCHECK(controller_);
     delete controller_;
     controller_ = NULL;
   }
 };
 
 TEST_F(MessagePumpLibeventTest, DeleteWatcher) {
   std::unique_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
   MessagePumpLibevent::FileDescriptorWatcher* watcher =
-      new MessagePumpLibevent::FileDescriptorWatcher;
+      new MessagePumpLibevent::FileDescriptorWatcher(FROM_HERE);
   DeleteWatcher delegate(watcher);
   pump->WatchFileDescriptor(pipefds_[1],
       false, MessagePumpLibevent::WATCH_READ_WRITE, watcher, &delegate);
 
   // Spoof a libevent notification.
   OnLibeventNotification(pump.get(), watcher);
 }
 
 class StopWatcher : public BaseWatcher {
  public:
   explicit StopWatcher(
       MessagePumpLibevent::FileDescriptorWatcher* controller)
       : BaseWatcher(controller) {}
 
   ~StopWatcher() override {}
 
   void OnFileCanWriteWithoutBlocking(int /* fd */) override {
     controller_->StopWatchingFileDescriptor();
   }
 };
 
 TEST_F(MessagePumpLibeventTest, StopWatcher) {
   std::unique_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
-  MessagePumpLibevent::FileDescriptorWatcher watcher;
+  MessagePumpLibevent::FileDescriptorWatcher watcher(FROM_HERE);
   StopWatcher delegate(&watcher);
   pump->WatchFileDescriptor(pipefds_[1],
       false, MessagePumpLibevent::WATCH_READ_WRITE, &watcher, &delegate);
 
   // Spoof a libevent notification.
   OnLibeventNotification(pump.get(), &watcher);
 }
 
 void QuitMessageLoopAndStart(const Closure& quit_closure) {
   quit_closure.Run();
@@ skipping 14 matching lines @@
     ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, Bind(&QuitMessageLoopAndStart, runloop.QuitClosure()));
     runloop.Run();
   }
 
   void OnFileCanWriteWithoutBlocking(int /* fd */) override {}
 };
 
 TEST_F(MessagePumpLibeventTest, NestedPumpWatcher) {
   std::unique_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
-  MessagePumpLibevent::FileDescriptorWatcher watcher;
+  MessagePumpLibevent::FileDescriptorWatcher watcher(FROM_HERE);
   NestedPumpWatcher delegate;
   pump->WatchFileDescriptor(pipefds_[1],
       false, MessagePumpLibevent::WATCH_READ, &watcher, &delegate);
 
   // Spoof a libevent notification.
   OnLibeventNotification(pump.get(), &watcher);
 }
 
 void FatalClosure() {
   FAIL() << "Reached fatal closure.";
@@ skipping 27 matching lines @@
 
 // Tests that MessagePumpLibevent quits immediately when it is quit from
 // libevent's event_base_loop().
 TEST_F(MessagePumpLibeventTest, QuitWatcher) {
   // Delete the old MessageLoop so that we can manage our own one here.
   ui_loop_.reset();
 
   MessagePumpLibevent* pump = new MessagePumpLibevent;  // owned by |loop|.
   MessageLoop loop(WrapUnique(pump));
   RunLoop run_loop;
-  MessagePumpLibevent::FileDescriptorWatcher controller;
+  MessagePumpLibevent::FileDescriptorWatcher controller(FROM_HERE);
   QuitWatcher delegate(&controller, &run_loop);
   WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
                       WaitableEvent::InitialState::NOT_SIGNALED);
   std::unique_ptr<WaitableEventWatcher> watcher(new WaitableEventWatcher);
 
   // Tell the pump to watch the pipe.
   pump->WatchFileDescriptor(pipefds_[0], false, MessagePumpLibevent::WATCH_READ,
                             &controller, &delegate);
 
   // Make the IO thread wait for |event| before writing to pipefds[1].
@@ skipping 13 matching lines @@
 
   // StartWatching can move |watcher| to IO thread. Release on IO thread.
   io_loop()->task_runner()->PostTask(
       FROM_HERE,
       Bind(&WaitableEventWatcher::StopWatching, Owned(watcher.release())));
 }
 
 }  // namespace
 
 }  // namespace base