1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef BASE_MESSAGE_PUMP_LIBEVENT_H_
6 #define BASE_MESSAGE_PUMP_LIBEVENT_H_
9 #include "base/basictypes.h"
10 #include "base/memory/weak_ptr.h"
11 #include "base/message_pump.h"
12 #include "base/observer_list.h"
13 #include "base/threading/thread_checker.h"
14 #include "base/time.h"
16 // Declare structs we need from libevent.h rather than including it
22 // Class to monitor sockets and issue callbacks when sockets are ready for I/O
23 // TODO(dkegel): add support for background file IO somehow
24 class BASE_API MessagePumpLibevent
: public MessagePump
{
30 // An IOObserver is an object that receives IO notifications from the
33 // NOTE: An IOObserver implementation should be extremely fast!
34 virtual void WillProcessIOEvent() = 0;
35 virtual void DidProcessIOEvent() = 0;
38 virtual ~IOObserver() {}
41 class FileDescriptorWatcher
;
43 // Used with WatchFileDescriptor to asynchronously monitor the I/O readiness
44 // of a file descriptor.
48 // Called from MessageLoop::Run when an FD can be read from/written to
50 virtual void OnFileCanReadWithoutBlocking(int fd
) = 0;
51 virtual void OnFileCanWriteWithoutBlocking(int fd
) = 0;
54 // Object returned by WatchFileDescriptor to manage further watching.
55 class FileDescriptorWatcher
{
57 FileDescriptorWatcher();
58 ~FileDescriptorWatcher(); // Implicitly calls StopWatchingFileDescriptor.
60 // NOTE: These methods aren't called StartWatching()/StopWatching() to
61 // avoid confusion with the win32 ObjectWatcher class.
63 // Stop watching the FD, always safe to call. No-op if there's nothing
65 bool StopWatchingFileDescriptor();
68 friend class MessagePumpLibevent
;
69 friend class MessagePumpLibeventTest
;
71 // Called by MessagePumpLibevent, ownership of |e| is transferred to this
73 void Init(event
* e
, bool is_persistent
);
75 // Used by MessagePumpLibevent to take ownership of event_.
76 event
*ReleaseEvent();
78 void set_pump(MessagePumpLibevent
* pump
) { pump_
= pump
; }
79 MessagePumpLibevent
* pump() { return pump_
; }
81 void set_watcher(Watcher
* watcher
) { watcher_
= watcher
; }
83 void OnFileCanReadWithoutBlocking(int fd
, MessagePumpLibevent
* pump
);
84 void OnFileCanWriteWithoutBlocking(int fd
, MessagePumpLibevent
* pump
);
86 bool is_persistent_
; // false if this event is one-shot.
88 MessagePumpLibevent
* pump_
;
90 base::WeakPtrFactory
<FileDescriptorWatcher
> weak_factory_
;
92 DISALLOW_COPY_AND_ASSIGN(FileDescriptorWatcher
);
98 WATCH_READ_WRITE
= WATCH_READ
| WATCH_WRITE
101 MessagePumpLibevent();
102 virtual ~MessagePumpLibevent();
104 // Have the current thread's message loop watch for a a situation in which
105 // reading/writing to the FD can be performed without blocking.
106 // Callers must provide a preallocated FileDescriptorWatcher object which
107 // can later be used to manage the lifetime of this event.
108 // If a FileDescriptorWatcher is passed in which is already attached to
109 // an event, then the effect is cumulative i.e. after the call |controller|
110 // will watch both the previous event and the new one.
111 // If an error occurs while calling this method in a cumulative fashion, the
112 // event previously attached to |controller| is aborted.
113 // Returns true on success.
114 // Must be called on the same thread the message_pump is running on.
115 // TODO(dkegel): switch to edge-triggered readiness notification
116 bool WatchFileDescriptor(int fd
,
119 FileDescriptorWatcher
*controller
,
122 void AddIOObserver(IOObserver
* obs
);
123 void RemoveIOObserver(IOObserver
* obs
);
125 // MessagePump methods:
126 virtual void Run(Delegate
* delegate
);
128 virtual void ScheduleWork();
129 virtual void ScheduleDelayedWork(const TimeTicks
& delayed_work_time
);
132 friend class MessagePumpLibeventTest
;
134 void WillProcessIOEvent();
135 void DidProcessIOEvent();
137 // Risky part of constructor. Returns true on success.
140 // Called by libevent to tell us a registered FD can be read/written to.
141 static void OnLibeventNotification(int fd
, short flags
,
144 // Unix pipe used to implement ScheduleWork()
145 // ... callback; called by libevent inside Run() when pipe is ready to read
146 static void OnWakeup(int socket
, short flags
, void* context
);
148 // This flag is set to false when Run should return.
151 // This flag is set when inside Run.
154 // This flag is set if libevent has processed I/O events.
155 bool processed_io_events_
;
157 // The time at which we should call DoDelayedWork.
158 TimeTicks delayed_work_time_
;
160 // Libevent dispatcher. Watches all sockets registered with it, and sends
161 // readiness callbacks when a socket is ready for I/O.
162 event_base
* event_base_
;
164 // ... write end; ScheduleWork() writes a single byte to it
166 // ... read end; OnWakeup reads it and then breaks Run() out of its sleep
167 int wakeup_pipe_out_
;
168 // ... libevent wrapper for read end
169 event
* wakeup_event_
;
171 ObserverList
<IOObserver
> io_observers_
;
172 ThreadChecker watch_file_descriptor_caller_checker_
;
173 DISALLOW_COPY_AND_ASSIGN(MessagePumpLibevent
);
178 #endif // BASE_MESSAGE_PUMP_LIBEVENT_H_