Add a mechanism to extend a libevent based message pump.

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/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_pump.h"
@@ skipping 19 matching lines @@
     // MessagePump.
     //
     // NOTE: An IOObserver implementation should be extremely fast!
     virtual void WillProcessIOEvent() = 0;
     virtual void DidProcessIOEvent() = 0;
 
    protected:
     virtual ~IOObserver() {}
   };
 
+  // Called to poll for events during each loop.
+  // Should return true if any events were processed.
+  class EventSource {
+   public:
+    EventSource() {}
+
+    virtual bool Poll() = 0;
+
+   protected:
+    virtual ~EventSource() {}
+  };
+
   // Used with WatchFileDescriptor to asynchronously monitor the I/O readiness
   // of a file descriptor.
   class Watcher {
    public:
     // Called from MessageLoop::Run when an FD can be read from/written to
     // without blocking
     virtual void OnFileCanReadWithoutBlocking(int fd) = 0;
     virtual void OnFileCanWriteWithoutBlocking(int fd) = 0;
 
    protected:
@@ skipping 65 matching lines @@
   // TODO(dkegel): switch to edge-triggered readiness notification
   bool WatchFileDescriptor(int fd,
                            bool persistent,
                            int mode,
                            FileDescriptorWatcher *controller,
                            Watcher *delegate);
 
   void AddIOObserver(IOObserver* obs);
   void RemoveIOObserver(IOObserver* obs);
 
+  void SetEventSource(EventSource* event_source);
+  void ClearEventSource();
+
   // MessagePump methods:
   void Run(Delegate* delegate) override;
   void Quit() override;
   void ScheduleWork() override;
   void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
 
  private:
   friend class MessagePumpLibeventTest;
 
   void WillProcessIOEvent();
   void DidProcessIOEvent();
 
+  bool PollEventSource();
+
   // Risky part of constructor.  Returns true on success.
   bool Init();
 
   // Called by libevent to tell us a registered FD can be read/written to.
   static void OnLibeventNotification(int fd, short flags,
                                      void* context);
 
   // Unix pipe used to implement ScheduleWork()
   // ... callback; called by libevent inside Run() when pipe is ready to read
   static void OnWakeup(int socket, short flags, void* context);
@@ skipping 15 matching lines @@
   event_base* event_base_;
 
   // ... write end; ScheduleWork() writes a single byte to it
   int wakeup_pipe_in_;
   // ... read end; OnWakeup reads it and then breaks Run() out of its sleep
   int wakeup_pipe_out_;
   // ... libevent wrapper for read end
   event* wakeup_event_;
 
   ObserverList<IOObserver> io_observers_;
+  EventSource* event_source_;
   ThreadChecker watch_file_descriptor_caller_checker_;
   DISALLOW_COPY_AND_ASSIGN(MessagePumpLibevent);
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_PUMP_LIBEVENT_H_