0ff0a5c3a3a2861d18fba6acfba774b9b04839f6
[WebKit-https.git] / Source / WebCore / platform / CrossThreadCopier.h
1 /*
2  * Copyright (C) 2009, 2010 Google 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 are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef CrossThreadCopier_h
32 #define CrossThreadCopier_h
33
34 #include <wtf/Assertions.h>
35 #include <wtf/Forward.h>
36 #include <wtf/PassRefPtr.h>
37 #include <wtf/RefPtr.h>
38 #include <wtf/Threading.h>
39
40 namespace WebCore {
41
42     class IntRect;
43     class IntSize;
44     class URL;
45     class ResourceError;
46     class ResourceRequest;
47     class ResourceResponse;
48     class SessionID;
49     class ThreadSafeDataBuffer;
50     struct CrossThreadResourceResponseData;
51     struct CrossThreadResourceRequestData;
52     struct ThreadableLoaderOptions;
53
54     struct CrossThreadCopierBaseHelper {
55         template<typename T> struct RemovePointer {
56             typedef T Type;
57         };
58         template<typename T> struct RemovePointer<T*> {
59             typedef T Type;
60         };
61
62         template<typename T> struct RemovePointer<RefPtr<T>> {
63             typedef T Type;
64         };
65
66         template<typename T> struct RemovePointer<PassRefPtr<T>> {
67             typedef T Type;
68         };
69
70         template<typename T> struct IsEnumOrConvertibleToInteger {
71             static const bool value = std::is_integral<T>::value || std::is_enum<T>::value || std::is_convertible<T, long double>::value;
72         };
73
74         template<typename T> struct IsThreadSafeRefCountedPointer {
75             static const bool value = std::is_convertible<typename RemovePointer<T>::Type*, ThreadSafeRefCounted<typename RemovePointer<T>::Type>*>::value;
76         };
77     };
78
79     template<typename T> struct CrossThreadCopierPassThrough {
80         typedef T Type;
81         static Type copy(const T& parameter)
82         {
83             return parameter;
84         }
85     };
86
87     template<bool isEnumOrConvertibleToInteger, bool isThreadSafeRefCounted, typename T> struct CrossThreadCopierBase;
88
89     // Integers get passed through without any changes.
90     template<typename T> struct CrossThreadCopierBase<true, false, T> : public CrossThreadCopierPassThrough<T> {
91     };
92
93     // To allow a type to be passed across threads using its copy constructor, add a forward declaration of the type and
94     // a CopyThreadCopierBase<false, false, TypeName> : public CrossThreadCopierPassThrough<TypeName> { }; to this file.
95     template<> struct CrossThreadCopierBase<false, false, IntRect> : public CrossThreadCopierPassThrough<IntRect> {
96     };
97
98     template<> struct CrossThreadCopierBase<false, false, IntSize> : public CrossThreadCopierPassThrough<IntSize> {
99     };
100
101     // Custom copy methods.
102     template<typename T> struct CrossThreadCopierBase<false, true, T> {
103         typedef typename CrossThreadCopierBaseHelper::RemovePointer<T>::Type RefCountedType;
104         static_assert(std::is_convertible<RefCountedType*, ThreadSafeRefCounted<RefCountedType>*>::value, "T is not convertible to ThreadSafeRefCounted!");
105
106         typedef PassRefPtr<RefCountedType> Type;
107         WEBCORE_EXPORT static Type copy(const T& refPtr)
108         {
109             return refPtr;
110         }
111     };
112
113     template<> struct CrossThreadCopierBase<false, false, URL> {
114         typedef URL Type;
115         static Type copy(const URL&);
116     };
117
118     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, String> {
119         typedef String Type;
120         static Type copy(const String&);
121     };
122
123     template<> struct CrossThreadCopierBase<false, false, ResourceError> {
124         typedef ResourceError Type;
125         static Type copy(const ResourceError&);
126     };
127
128     template<> struct CrossThreadCopierBase<false, false, ResourceRequest> {
129         typedef std::unique_ptr<CrossThreadResourceRequestData> Type;
130         static Type copy(const ResourceRequest&);
131     };
132
133     template<> struct CrossThreadCopierBase<false, false, ResourceResponse> {
134         typedef std::unique_ptr<CrossThreadResourceResponseData> Type;
135         static Type copy(const ResourceResponse&);
136     };
137
138     template<> struct CrossThreadCopierBase<false, false, SessionID> {
139         typedef SessionID Type;
140         static Type copy(const SessionID&);
141     };
142
143     template<> struct CrossThreadCopierBase<false, false, ThreadSafeDataBuffer> {
144         typedef ThreadSafeDataBuffer Type;
145         static Type copy(const ThreadSafeDataBuffer&);
146     };
147
148 #if ENABLE(INDEXED_DATABASE)
149     namespace IndexedDB {
150         enum class TransactionMode;
151         enum class CursorDirection;
152         enum class CursorType;
153     }
154     template<> struct CrossThreadCopierBase<false, false, IndexedDB::TransactionMode> {
155         WEBCORE_EXPORT static IndexedDB::TransactionMode copy(const IndexedDB::TransactionMode&);
156     };
157     template<> struct CrossThreadCopierBase<false, false, IndexedDB::CursorDirection> {
158         WEBCORE_EXPORT static IndexedDB::CursorDirection copy(const IndexedDB::CursorDirection&);
159     };
160     template<> struct CrossThreadCopierBase<false, false, IndexedDB::CursorType> {
161         WEBCORE_EXPORT static IndexedDB::CursorType copy(const IndexedDB::CursorType&);
162     };
163
164     struct IDBDatabaseMetadata;
165     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBDatabaseMetadata> {
166         typedef IDBDatabaseMetadata Type;
167         static Type copy(const IDBDatabaseMetadata&);
168     };
169
170     struct IDBGetResult;
171     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBGetResult> {
172         typedef IDBGetResult Type;
173         static Type copy(const IDBGetResult&);
174     };
175
176     struct IDBIndexMetadata;
177     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBIndexMetadata> {
178         typedef IDBIndexMetadata Type;
179         static Type copy(const IDBIndexMetadata&);
180     };
181
182     class IDBKeyData;
183     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBKeyData> {
184         typedef IDBKeyData Type;
185         static Type copy(const IDBKeyData&);
186     };
187
188     struct IDBKeyRangeData;
189     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBKeyRangeData> {
190         typedef IDBKeyRangeData Type;
191         static Type copy(const IDBKeyRangeData&);
192     };
193
194     struct IDBObjectStoreMetadata;
195     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBObjectStoreMetadata> {
196         typedef IDBObjectStoreMetadata Type;
197         static Type copy(const IDBObjectStoreMetadata&);
198     };
199
200     class IDBDatabaseInfo;
201     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBDatabaseInfo> {
202         typedef IDBDatabaseInfo Type;
203         static Type copy(const IDBDatabaseInfo&);
204     };
205
206     class IDBDatabaseIdentifier;
207     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBDatabaseIdentifier> {
208         typedef IDBDatabaseIdentifier Type;
209         static Type copy(const IDBDatabaseIdentifier&);
210     };
211
212     class IDBError;
213     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBError> {
214         typedef IDBError Type;
215         static Type copy(const IDBError&);
216     };
217
218     class IDBResourceIdentifier;
219     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBResourceIdentifier> {
220         typedef IDBResourceIdentifier Type;
221         static Type copy(const IDBResourceIdentifier&);
222     };
223
224     class IDBTransactionInfo;
225     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBTransactionInfo> {
226         typedef IDBTransactionInfo Type;
227         static Type copy(const IDBTransactionInfo&);
228     };
229
230     class IDBObjectStoreInfo;
231     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBObjectStoreInfo> {
232         typedef IDBObjectStoreInfo Type;
233         static Type copy(const IDBObjectStoreInfo&);
234     };
235
236     class IDBIndexInfo;
237     template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBIndexInfo> {
238         typedef IDBIndexInfo Type;
239         static Type copy(const IDBIndexInfo&);
240     };
241
242 #endif
243
244     template<typename T>
245     struct CrossThreadCopier : public CrossThreadCopierBase<CrossThreadCopierBaseHelper::IsEnumOrConvertibleToInteger<T>::value, CrossThreadCopierBaseHelper::IsThreadSafeRefCountedPointer<T>::value, T> {
246     };
247
248     template<typename T> struct AllowCrossThreadAccessWrapper {
249     public:
250         explicit AllowCrossThreadAccessWrapper(T* value) : m_value(value) { }
251         T* value() const { return m_value; }
252     private:
253         T* m_value;
254     };
255
256     template<typename T> struct CrossThreadCopierBase<false, false, AllowCrossThreadAccessWrapper<T>> {
257         typedef T* Type;
258         static Type copy(const AllowCrossThreadAccessWrapper<T>& wrapper) { return wrapper.value(); }
259     };
260
261     template<typename T> AllowCrossThreadAccessWrapper<T> AllowCrossThreadAccess(T* value) 
262     {
263         return AllowCrossThreadAccessWrapper<T>(value);
264     }
265
266     // FIXME: Move to a different header file. AllowAccessLater is for cross-thread access
267     // that is not cross-thread (tasks posted to a queue guaranteed to run on the same thread).
268     template<typename T> struct AllowAccessLaterWrapper {
269     public:
270         explicit AllowAccessLaterWrapper(T* value) : m_value(value) { }
271         T* value() const { return m_value; }
272     private:
273         T* m_value;
274     };
275
276     template<typename T> struct CrossThreadCopierBase<false, false, AllowAccessLaterWrapper<T>> {
277         typedef T* Type;
278         static Type copy(const AllowAccessLaterWrapper<T>& wrapper) { return wrapper.value(); }
279     };
280
281     template<typename T> AllowAccessLaterWrapper<T> AllowAccessLater(T* value)
282     {
283         return AllowAccessLaterWrapper<T>(value);
284     }
285
286
287 } // namespace WebCore
288
289 #endif // CrossThreadCopier_h