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

base/message_loop/message_pump_libevent.h

 // 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.
 
 #ifndef BASE_MESSAGE_LOOP_MESSAGE_PUMP_LIBEVENT_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_PUMP_LIBEVENT_H_
 
 #include "base/compiler_specific.h"
+#include "base/location.h"
 #include "base/macros.h"
 #include "base/message_loop/message_pump.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 
 // Declare structs we need from libevent.h rather than including it
 struct event_base;
 struct event;
 
 namespace base {
@@ skipping 11 matching lines @@
     virtual void OnFileCanReadWithoutBlocking(int fd) = 0;
     virtual void OnFileCanWriteWithoutBlocking(int fd) = 0;
 
    protected:
     virtual ~Watcher() {}
   };
 
   // Object returned by WatchFileDescriptor to manage further watching.
   class FileDescriptorWatcher {
    public:
-    FileDescriptorWatcher();
+    explicit FileDescriptorWatcher(const tracked_objects::Location& from_here);
     ~FileDescriptorWatcher();  // Implicitly calls StopWatchingFileDescriptor.
 
     // NOTE: These methods aren't called StartWatching()/StopWatching() to
     // avoid confusion with the win32 ObjectWatcher class.
 
     // Stop watching the FD, always safe to call.  No-op if there's nothing
     // to do.
     bool StopWatchingFileDescriptor();
 
+    const tracked_objects::Location& created_from_location() {
+      return created_from_location_;
+    }
+
    private:
     friend class MessagePumpLibevent;
     friend class MessagePumpLibeventTest;
 
     // Called by MessagePumpLibevent, ownership of |e| is transferred to this
     // object.
     void Init(event* e);
 
     // Used by MessagePumpLibevent to take ownership of event_.
     event* ReleaseEvent();
 
     void set_pump(MessagePumpLibevent* pump) { pump_ = pump; }
     MessagePumpLibevent* pump() const { return pump_; }
 
     void set_watcher(Watcher* watcher) { watcher_ = watcher; }
 
     void OnFileCanReadWithoutBlocking(int fd, MessagePumpLibevent* pump);
     void OnFileCanWriteWithoutBlocking(int fd, MessagePumpLibevent* pump);
 
     event* event_;
     MessagePumpLibevent* pump_;
     Watcher* watcher_;
     // If this pointer is non-NULL, the pointee is set to true in the
     // destructor.
     bool* was_destroyed_;
 
+    const tracked_objects::Location created_from_location_;
+
     DISALLOW_COPY_AND_ASSIGN(FileDescriptorWatcher);
   };
 
   enum Mode {
     WATCH_READ = 1 << 0,
     WATCH_WRITE = 1 << 1,
     WATCH_READ_WRITE = WATCH_READ | WATCH_WRITE
   };
 
   MessagePumpLibevent();
@@ skipping 59 matching lines @@
   // ... libevent wrapper for read end
   event* wakeup_event_;
 
   ThreadChecker watch_file_descriptor_caller_checker_;
   DISALLOW_COPY_AND_ASSIGN(MessagePumpLibevent);
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_PUMP_LIBEVENT_H_