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_GLIB_H_
6 #define BASE_MESSAGE_PUMP_GLIB_H_
9 #include "base/memory/scoped_ptr.h"
10 #include "base/message_pump.h"
11 #include "base/observer_list.h"
12 #include "base/time.h"
14 typedef struct _GMainContext GMainContext
;
15 typedef struct _GPollFD GPollFD
;
16 typedef struct _GSource GSource
;
20 // MessagePumpObserver is notified prior to an event being dispatched. As
21 // Observers are notified of every change, they have to be FAST! The platform
22 // specific implementation of the class is in message_pump_gtk/message_pump_x.
23 class MessagePumpObserver
;
25 // MessagePumpDispatcher is used during a nested invocation of Run to dispatch
26 // events. If Run is invoked with a non-NULL MessagePumpDispatcher, MessageLoop
27 // does not dispatch events (or invoke gtk_main_do_event), rather every event is
28 // passed to Dispatcher's Dispatch method for dispatch. It is up to the
29 // Dispatcher to dispatch, or not, the event. The platform specific
30 // implementation of the class is in message_pump_gtk/message_pump_x.
31 class MessagePumpDispatcher
;
33 // This class implements a base MessagePump needed for TYPE_UI MessageLoops on
34 // platforms using GLib.
35 class MessagePumpGlib
: public MessagePump
{
38 virtual ~MessagePumpGlib();
40 // Like MessagePump::Run, but events are routed through dispatcher.
41 virtual void RunWithDispatcher(Delegate
* delegate
,
42 MessagePumpDispatcher
* dispatcher
);
44 // Run a single iteration of the mainloop. A return value of true indicates
45 // that an event was handled. |block| indicates if it should wait if no event
46 // is ready for processing.
47 virtual bool RunOnce(GMainContext
* context
, bool block
) = 0;
49 // Internal methods used for processing the pump callbacks. They are
50 // public for simplicity but should not be used directly. HandlePrepare
51 // is called during the prepare step of glib, and returns a timeout that
52 // will be passed to the poll. HandleCheck is called after the poll
53 // has completed, and returns whether or not HandleDispatch should be called.
54 // HandleDispatch is called if HandleCheck returned true.
57 void HandleDispatch();
59 // Adds an Observer, which will start receiving notifications immediately.
60 void AddObserver(MessagePumpObserver
* observer
);
62 // Removes an Observer. It is safe to call this method while an Observer is
63 // receiving a notification callback.
64 void RemoveObserver(MessagePumpObserver
* observer
);
66 // Overridden from MessagePump:
67 virtual void Run(Delegate
* delegate
);
69 virtual void ScheduleWork();
70 virtual void ScheduleDelayedWork(const TimeTicks
& delayed_work_time
);
73 // Returns the dispatcher for the current run state (|state_->dispatcher|).
74 MessagePumpDispatcher
* GetDispatcher();
76 ObserverList
<MessagePumpObserver
>& observers() { return observers_
; }
79 // We may make recursive calls to Run, so we save state that needs to be
80 // separate between them in this structure type.
85 // This is a GLib structure that we can add event sources to. We use the
86 // default GLib context, which is the one to which all GTK events are
88 GMainContext
* context_
;
90 // This is the time when we need to do delayed work.
91 TimeTicks delayed_work_time_
;
93 // The work source. It is shared by all calls to Run and destroyed when
94 // the message pump is destroyed.
95 GSource
* work_source_
;
97 // We use a wakeup pipe to make sure we'll get out of the glib polling phase
98 // when another thread has scheduled us to do some work. There is a glib
99 // mechanism g_main_context_wakeup, but this won't guarantee that our event's
100 // Dispatch() will be called.
101 int wakeup_pipe_read_
;
102 int wakeup_pipe_write_
;
103 // Use a scoped_ptr to avoid needing the definition of GPollFD in the header.
104 scoped_ptr
<GPollFD
> wakeup_gpollfd_
;
106 // List of observers.
107 ObserverList
<MessagePumpObserver
> observers_
;
109 DISALLOW_COPY_AND_ASSIGN(MessagePumpGlib
);
114 #endif // BASE_MESSAGE_PUMP_GLIB_H_