Added new port JSCOnly.
[WebKit-https.git] / Source / WTF / wtf / WorkQueue.h
1 /*
2  * Copyright (C) 2010, 2015 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 #include <chrono>
31 #include <functional>
32 #include <wtf/Forward.h>
33 #include <wtf/FunctionDispatcher.h>
34 #include <wtf/RefCounted.h>
35 #include <wtf/Threading.h>
36
37 #if OS(DARWIN) && !PLATFORM(GTK)
38 #include <dispatch/dispatch.h>
39 #endif
40
41 #if PLATFORM(EFL)
42 #include <DispatchQueueEfl.h>
43 #elif USE(GLIB)
44 #include <wtf/Condition.h>
45 #include <wtf/RunLoop.h>
46 #include <wtf/glib/GRefPtr.h>
47 #elif OS(WINDOWS)
48 #include <wtf/HashMap.h>
49 #include <wtf/Vector.h>
50 #include <wtf/win/WorkItemWin.h>
51 #endif
52
53 namespace WTF {
54
55 class WorkQueue final : public FunctionDispatcher {
56 public:
57     enum class Type {
58         Serial,
59         Concurrent
60     };
61     enum class QOS {
62         UserInteractive,
63         UserInitiated,
64         Default,
65         Utility,
66         Background
67     };
68     
69     WTF_EXPORT_PRIVATE static Ref<WorkQueue> create(const char* name, Type = Type::Serial, QOS = QOS::Default);
70     virtual ~WorkQueue();
71
72     WTF_EXPORT_PRIVATE void dispatch(std::function<void ()>) override;
73     WTF_EXPORT_PRIVATE void dispatchAfter(std::chrono::nanoseconds, std::function<void ()>);
74
75     WTF_EXPORT_PRIVATE static void concurrentApply(size_t iterations, const std::function<void (size_t index)>&);
76
77 #if PLATFORM(EFL)
78     void registerSocketEventHandler(int, std::function<void ()>);
79     void unregisterSocketEventHandler(int);
80 #elif USE(GLIB)
81     RunLoop& runLoop() const { return *m_runLoop; }
82 #elif OS(DARWIN)
83     dispatch_queue_t dispatchQueue() const { return m_dispatchQueue; }
84 #endif
85
86 private:
87     explicit WorkQueue(const char* name, Type, QOS);
88
89     void platformInitialize(const char* name, Type, QOS);
90     void platformInvalidate();
91
92 #if OS(WINDOWS)
93     static void CALLBACK handleCallback(void* context, BOOLEAN timerOrWaitFired);
94     static void CALLBACK timerCallback(void* context, BOOLEAN timerOrWaitFired);
95     static DWORD WINAPI workThreadCallback(void* context);
96
97     bool tryRegisterAsWorkThread();
98     void unregisterAsWorkThread();
99     void performWorkOnRegisteredWorkThread();
100
101     static void unregisterWaitAndDestroyItemSoon(PassRefPtr<HandleWorkItem>);
102     static DWORD WINAPI unregisterWaitAndDestroyItemCallback(void* context);
103 #endif
104
105 #if PLATFORM(EFL)
106     RefPtr<DispatchQueue> m_dispatchQueue;
107 #elif USE(GLIB)
108     ThreadIdentifier m_workQueueThread;
109     Lock m_initializeRunLoopConditionMutex;
110     Condition m_initializeRunLoopCondition;
111     RunLoop* m_runLoop;
112     Lock m_terminateRunLoopConditionMutex;
113     Condition m_terminateRunLoopCondition;
114 #elif OS(DARWIN)
115     static void executeFunction(void*);
116     dispatch_queue_t m_dispatchQueue;
117 #elif OS(WINDOWS)
118     volatile LONG m_isWorkThreadRegistered;
119
120     Mutex m_workItemQueueLock;
121     Vector<RefPtr<WorkItemWin>> m_workItemQueue;
122
123     Mutex m_handlesLock;
124     HashMap<HANDLE, RefPtr<HandleWorkItem>> m_handles;
125
126     HANDLE m_timerQueue;
127 #endif
128 };
129
130 }
131
132 using WTF::WorkQueue;
133
134 #endif