WTF shouldn't have both Thread and ThreadIdentifier
[WebKit.git] / Source / WebKit / UIProcess / GenericCallback.h
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include "APIError.h"
29 #include "APISerializedScriptValue.h"
30 #include "CallbackID.h"
31 #include "ProcessThrottler.h"
32 #include "ShareableBitmap.h"
33 #include "WKAPICast.h"
34 #include <wtf/Function.h>
35 #include <wtf/HashMap.h>
36 #include <wtf/MainThread.h>
37 #include <wtf/RefCounted.h>
38 #include <wtf/Threading.h>
39
40 namespace WebKit {
41
42 class CallbackBase : public RefCounted<CallbackBase> {
43 public:
44     enum class Error {
45         None,
46         Unknown,
47         ProcessExited,
48         OwnerWasInvalidated,
49     };
50
51     virtual ~CallbackBase()
52     {
53     }
54
55     CallbackID callbackID() const { return m_callbackID; }
56
57     template<class T>
58     T* as()
59     {
60         if (T::type() == m_type)
61             return static_cast<T*>(this);
62
63         return nullptr;
64     }
65
66     virtual void invalidate(Error) = 0;
67
68 protected:
69     struct TypeTag { };
70     typedef const TypeTag* Type;
71
72     explicit CallbackBase(Type type, const ProcessThrottler::BackgroundActivityToken& activityToken)
73         : m_type(type)
74         , m_callbackID(CallbackID::generateID())
75         , m_activityToken(activityToken)
76     {
77     }
78
79 private:
80     Type m_type;
81     CallbackID m_callbackID;
82     ProcessThrottler::BackgroundActivityToken m_activityToken;
83 };
84
85 template<typename... T>
86 class GenericCallback : public CallbackBase {
87 public:
88     typedef Function<void (T..., Error)> CallbackFunction;
89
90     static Ref<GenericCallback> create(CallbackFunction&& callback, const ProcessThrottler::BackgroundActivityToken& activityToken = nullptr)
91     {
92         return adoptRef(*new GenericCallback(WTFMove(callback), activityToken));
93     }
94
95     virtual ~GenericCallback()
96     {
97         ASSERT(m_originThread.ptr() == &Thread::current());
98         ASSERT(!m_callback);
99     }
100
101     void performCallbackWithReturnValue(T... returnValue)
102     {
103         ASSERT(m_originThread.ptr() == &Thread::current());
104
105         if (!m_callback)
106             return;
107
108         m_callback.value()(returnValue..., Error::None);
109
110         m_callback = std::nullopt;
111     }
112
113     void performCallback()
114     {
115         performCallbackWithReturnValue();
116     }
117
118     void invalidate(Error error = Error::Unknown) final
119     {
120         ASSERT(m_originThread.ptr() == &Thread::current());
121
122         if (!m_callback)
123             return;
124
125         m_callback.value()(typename std::remove_reference<T>::type()..., error);
126
127         m_callback = std::nullopt;
128     }
129
130 private:
131     GenericCallback(CallbackFunction&& callback, const ProcessThrottler::BackgroundActivityToken& activityToken)
132         : CallbackBase(type(), activityToken)
133         , m_callback(WTFMove(callback))
134     {
135     }
136
137     friend class CallbackBase;
138     static Type type()
139     {
140         static TypeTag tag;
141         return &tag;
142     }
143
144     std::optional<CallbackFunction> m_callback;
145
146 #ifndef NDEBUG
147     Ref<Thread> m_originThread { Thread::current() };
148 #endif
149 };
150
151 template<typename APIReturnValueType, typename InternalReturnValueType = typename APITypeInfo<APIReturnValueType>::ImplType*>
152 static typename GenericCallback<InternalReturnValueType>::CallbackFunction toGenericCallbackFunction(void* context, void (*callback)(APIReturnValueType, WKErrorRef, void*))
153 {
154     return [context, callback](InternalReturnValueType returnValue, CallbackBase::Error error) {
155         callback(toAPI(returnValue), error != CallbackBase::Error::None ? toAPI(API::Error::create().ptr()) : 0, context);
156     };
157 }
158
159 typedef GenericCallback<> VoidCallback;
160 typedef GenericCallback<const Vector<WebCore::IntRect>&, double> ComputedPagesCallback;
161 typedef GenericCallback<const ShareableBitmap::Handle&> ImageCallback;
162
163 template<typename T>
164 void invalidateCallbackMap(HashMap<uint64_t, T>& callbackMap, CallbackBase::Error error)
165 {
166     for (auto& callback : copyToVector(callbackMap.values()))
167         callback->invalidate(error);
168
169     callbackMap.clear();
170 }
171
172 class CallbackMap {
173 public:
174     CallbackID put(Ref<CallbackBase>&& callback)
175     {
176         RELEASE_ASSERT(RunLoop::isMain());
177         auto callbackID = callback->callbackID();
178         RELEASE_ASSERT(callbackID.isValid());
179         RELEASE_ASSERT(!m_map.contains(callbackID.m_id));
180         m_map.set(callbackID.m_id, WTFMove(callback));
181         return callbackID;
182     }
183
184     template<unsigned I, typename T, typename... U>
185     struct GenericCallbackType {
186         typedef typename GenericCallbackType<I - 1, U..., T>::type type;
187     };
188
189     template<typename... U>
190     struct GenericCallbackType<1, CallbackBase::Error, U...> {
191         typedef GenericCallback<U...> type;
192     };
193
194     template<typename... T>
195     CallbackID put(Function<void(T...)>&& function, const ProcessThrottler::BackgroundActivityToken& activityToken)
196     {
197         auto callback = GenericCallbackType<sizeof...(T), T...>::type::create(WTFMove(function), activityToken);
198         return put(WTFMove(callback));
199     }
200
201     // FIXME: <webkit.org/b/174007> WebCookieManagerProxy should pass in BackgroundActivityToken
202     template<typename... T>
203     CallbackID put(Function<void(T...)>&& function)
204     {
205         auto callback = GenericCallbackType<sizeof...(T), T...>::type::create(WTFMove(function));
206         return put(WTFMove(callback));
207     }
208
209     template<class T>
210     RefPtr<T> take(CallbackID callbackID)
211     {
212         RELEASE_ASSERT(callbackID.isValid());
213         RELEASE_ASSERT(RunLoop::isMain());
214         auto base = m_map.take(callbackID.m_id);
215         if (!base)
216             return nullptr;
217
218         return adoptRef(base.leakRef()->as<T>());
219     }
220
221     void invalidate(CallbackBase::Error error)
222     {
223         RELEASE_ASSERT(RunLoop::isMain());
224         invalidateCallbackMap(m_map, error);
225     }
226
227 private:
228     HashMap<uint64_t, RefPtr<CallbackBase>> m_map;
229 };
230
231 } // namespace WebKit