Remove unused parameters from WTF threading API
[WebKit-https.git] / Source / WebKit2 / Platform / WorkQueue.h
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  * Portions Copyright (c) 2010 Motorola Mobility, Inc.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #ifndef WorkQueue_h
28 #define WorkQueue_h
29
30 #if OS(DARWIN)
31 #if HAVE(DISPATCH_H)
32 #include <dispatch/dispatch.h>
33 #endif
34 #endif
35
36 #include <wtf/Forward.h>
37 #include <wtf/Functional.h>
38 #include <wtf/HashMap.h>
39 #include <wtf/PassOwnPtr.h>
40 #include <wtf/RefCounted.h>
41 #include <wtf/Threading.h>
42 #include <wtf/Vector.h>
43
44 #if PLATFORM(QT) && !OS(DARWIN)
45 #include <QSocketNotifier>
46 #include "PlatformProcessIdentifier.h"
47 class QObject;
48 class QThread;
49 #elif PLATFORM(GTK)
50 #include "PlatformProcessIdentifier.h"
51 typedef struct _GMainContext GMainContext;
52 typedef struct _GMainLoop GMainLoop;
53 typedef gboolean (*GSourceFunc) (gpointer data);
54 #endif
55
56 class WorkQueue {
57     WTF_MAKE_NONCOPYABLE(WorkQueue);
58
59 public:
60     explicit WorkQueue(const char* name);
61     ~WorkQueue();
62
63     // Will dispatch the given function to run as soon as possible.
64     void dispatch(const Function<void()>&);
65
66     // Will dispatch the given function after the given delay (in seconds).
67     void dispatchAfterDelay(const Function<void()>&, double delay);
68
69     void invalidate();
70
71 #if OS(DARWIN)
72     enum MachPortEventType {
73         // Fired when there is data on the given receive right.
74         MachPortDataAvailable,
75         
76         // Fired when the receive right for this send right has been destroyed.
77         MachPortDeadNameNotification
78     };
79     
80     // Will execute the given function whenever the given mach port event fires.
81     // Note that this will adopt the mach port and destroy it when the work queue is invalidated.
82     void registerMachPortEventHandler(mach_port_t, MachPortEventType, const Function<void()>&);
83     void unregisterMachPortEventHandler(mach_port_t);
84 #elif PLATFORM(WIN)
85     void registerHandle(HANDLE, const Function<void()>&);
86     void unregisterAndCloseHandle(HANDLE);
87 #elif PLATFORM(QT)
88     QSocketNotifier* registerSocketEventHandler(int, QSocketNotifier::Type, const Function<void()>&);
89     void dispatchOnTermination(WebKit::PlatformProcessIdentifier, const Function<void()>&);
90 #elif PLATFORM(GTK)
91     void registerEventSourceHandler(int, int, const Function<void()>&);
92     void unregisterEventSourceHandler(int);
93     void dispatchOnTermination(WebKit::PlatformProcessIdentifier, const Function<void()>&);
94 #endif
95
96 private:
97     // FIXME: Use an atomic boolean here instead.
98     Mutex m_isValidMutex;
99     bool m_isValid;
100
101     void platformInitialize(const char* name);
102     void platformInvalidate();
103
104 #if OS(DARWIN)
105 #if HAVE(DISPATCH_H)
106     static void executeFunction(void*);
107     Mutex m_eventSourcesMutex;
108     class EventSource;
109     HashMap<mach_port_t, EventSource*> m_eventSources;
110     dispatch_queue_t m_dispatchQueue;
111 #endif
112 #elif PLATFORM(WIN)
113     class WorkItemWin : public ThreadSafeRefCounted<WorkItemWin> {
114     public:
115         static PassRefPtr<WorkItemWin> create(const Function<void()>&, WorkQueue*);
116         virtual ~WorkItemWin();
117
118         Function<void()>& function() { return m_function; }
119         WorkQueue* queue() const { return m_queue; }
120
121     protected:
122         WorkItemWin(const Function<void()>&, WorkQueue*);
123
124     private:
125         Function<void()> m_function;
126         WorkQueue* m_queue;
127     };
128
129     class HandleWorkItem : public WorkItemWin {
130     public:
131         static PassRefPtr<HandleWorkItem> createByAdoptingHandle(HANDLE, const Function<void()>&, WorkQueue*);
132         virtual ~HandleWorkItem();
133
134         void setWaitHandle(HANDLE waitHandle) { m_waitHandle = waitHandle; }
135         HANDLE waitHandle() const { return m_waitHandle; }
136
137     private:
138         HandleWorkItem(HANDLE, const Function<void()>&, WorkQueue*);
139
140         HANDLE m_handle;
141         HANDLE m_waitHandle;
142     };
143
144     static void CALLBACK handleCallback(void* context, BOOLEAN timerOrWaitFired);
145     static void CALLBACK timerCallback(void* context, BOOLEAN timerOrWaitFired);
146     static DWORD WINAPI workThreadCallback(void* context);
147
148     bool tryRegisterAsWorkThread();
149     void unregisterAsWorkThread();
150     void performWorkOnRegisteredWorkThread();
151
152     static void unregisterWaitAndDestroyItemSoon(PassRefPtr<HandleWorkItem>);
153     static DWORD WINAPI unregisterWaitAndDestroyItemCallback(void* context);
154
155     volatile LONG m_isWorkThreadRegistered;
156
157     Mutex m_workItemQueueLock;
158     Vector<RefPtr<WorkItemWin> > m_workItemQueue;
159
160     Mutex m_handlesLock;
161     HashMap<HANDLE, RefPtr<HandleWorkItem> > m_handles;
162
163     HANDLE m_timerQueue;
164 #elif PLATFORM(QT)
165     class WorkItemQt;
166     QThread* m_workThread;
167     friend class WorkItemQt;
168 #elif PLATFORM(GTK)
169     static void startWorkQueueThread(WorkQueue*);
170     void workQueueThreadBody();
171     void dispatchOnSource(GSource*, const Function<void()>&, GSourceFunc);
172
173     ThreadIdentifier m_workQueueThread;
174     GMainContext* m_eventContext;
175     Mutex m_eventLoopLock;
176     GMainLoop* m_eventLoop;
177     Mutex m_eventSourcesLock;
178     class EventSource;
179     HashMap<int, Vector<EventSource*> > m_eventSources;
180     typedef HashMap<int, Vector<EventSource*> >::iterator EventSourceIterator; 
181 #endif
182 };
183
184 #endif // WorkQueue_h