[EFL][WK2] Add RunLoopEfl and WorkQueueEfl
[WebKit-https.git] / Source / WebCore / platform / RunLoop.h
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
4  * Portions Copyright (c) 2010 Motorola Mobility, Inc.  All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
19  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
25  * THE POSSIBILITY OF SUCH DAMAGE.
26  */
27
28 #ifndef RunLoop_h
29 #define RunLoop_h
30
31 #include <wtf/Forward.h>
32 #include <wtf/Functional.h>
33 #include <wtf/HashMap.h>
34 #include <wtf/ThreadSpecific.h>
35 #include <wtf/Threading.h>
36 #include <wtf/Vector.h>
37
38 #if PLATFORM(GTK)
39 #include <wtf/gobject/GRefPtr.h>
40 #endif
41
42 #if PLATFORM(EFL)
43 #include <Ecore.h>
44 #endif
45
46 namespace WebCore {
47
48 class RunLoop {
49 public:
50     // Must be called from the main thread (except for the Mac platform, where it
51     // can be called from any thread).
52     static void initializeMainRunLoop();
53
54     static RunLoop* current();
55     static RunLoop* main();
56
57     void dispatch(const Function<void()>&);
58
59     static void run();
60     void stop();
61
62 #if PLATFORM(MAC)
63     void runForDuration(double duration);
64 #endif
65     
66     class TimerBase {
67         friend class RunLoop;
68     public:
69         TimerBase(RunLoop*);
70         virtual ~TimerBase();
71
72         void startRepeating(double repeatInterval) { start(repeatInterval, true); }
73         void startOneShot(double interval) { start(interval, false); }
74
75         void stop();
76         bool isActive() const;
77
78         virtual void fired() = 0;
79
80     private:
81         void start(double nextFireInterval, bool repeat);
82
83         RunLoop* m_runLoop;
84
85 #if PLATFORM(WIN)
86         static void timerFired(RunLoop*, uint64_t ID);
87         uint64_t m_ID;
88         bool m_isRepeating;
89 #elif PLATFORM(MAC)
90         static void timerFired(CFRunLoopTimerRef, void*);
91         CFRunLoopTimerRef m_timer;
92 #elif PLATFORM(QT)
93         static void timerFired(RunLoop*, int ID);
94         int m_ID;
95         bool m_isRepeating;
96 #elif PLATFORM(GTK)
97         static gboolean timerFiredCallback(RunLoop::TimerBase*);
98         gboolean isRepeating() const { return m_isRepeating; }
99         void clearTimerSource();
100         GRefPtr<GSource> m_timerSource;
101         gboolean m_isRepeating;
102 #elif PLATFORM(EFL)
103         static bool timerFired(void* data);
104         OwnPtr<Ecore_Timer> m_timer;
105         bool m_isRepeating;
106 #endif
107     };
108
109     template <typename TimerFiredClass>
110     class Timer : public TimerBase {
111     public:
112         typedef void (TimerFiredClass::*TimerFiredFunction)();
113
114         Timer(RunLoop* runLoop, TimerFiredClass* o, TimerFiredFunction f)
115             : TimerBase(runLoop)
116             , m_object(o)
117             , m_function(f)
118         {
119         }
120
121     private:
122         virtual void fired() { (m_object->*m_function)(); }
123
124         TimerFiredClass* m_object;
125         TimerFiredFunction m_function;
126     };
127
128 private:
129     friend class WTF::ThreadSpecific<RunLoop>;
130
131     RunLoop();
132     ~RunLoop();
133
134     void performWork();
135     void wakeUp();
136
137     Mutex m_functionQueueLock;
138     Vector<Function<void()> > m_functionQueue;
139
140 #if PLATFORM(WIN)
141     static bool registerRunLoopMessageWindowClass();
142     static LRESULT CALLBACK RunLoopWndProc(HWND, UINT, WPARAM, LPARAM);
143     LRESULT wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
144     HWND m_runLoopMessageWindow;
145
146     typedef HashMap<uint64_t, TimerBase*> TimerMap;
147     TimerMap m_activeTimers;
148 #elif PLATFORM(MAC)
149     RunLoop(CFRunLoopRef);
150     static void performWork(void*);
151     CFRunLoopRef m_runLoop;
152     CFRunLoopSourceRef m_runLoopSource;
153     int m_nestingLevel;
154 #elif PLATFORM(QT)
155     typedef HashMap<int, TimerBase*> TimerMap;
156     TimerMap m_activeTimers;
157     class TimerObject;
158     TimerObject* m_timerObject;
159 #elif PLATFORM(GTK)
160 public:
161     static gboolean queueWork(RunLoop*);
162     GMainLoop* innermostLoop();
163     void pushNestedMainLoop(GMainLoop*);
164     void popNestedMainLoop();
165 private:
166     GRefPtr<GMainContext> m_runLoopContext;
167     Vector<GRefPtr<GMainLoop> > m_runLoopMainLoops;
168 #elif PLATFORM(EFL)
169     bool m_initEfl;
170     OwnPtr<Ecore_Pipe> m_pipe;
171     static void wakeUpEvent(void* data, void*, unsigned int);
172 #endif
173 };
174
175 } // namespace WebCore
176
177 #endif // RunLoop_h