IDB: Implement cross-thread and IPC plumbing for 'get' support
[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/PassOwnPtr.h>
37 #include <wtf/PassRefPtr.h>
38 #include <wtf/RefPtr.h>
39 #include <wtf/Threading.h>
40
41 namespace WebCore {
42
43     class IntRect;
44     class IntSize;
45     class URL;
46     class ResourceError;
47     class ResourceRequest;
48     class ResourceResponse;
49     struct CrossThreadResourceResponseData;
50     struct CrossThreadResourceRequestData;
51     struct ThreadableLoaderOptions;
52
53     struct CrossThreadCopierBaseHelper {
54         template<typename T> struct RemovePointer {
55             typedef T Type;
56         };
57         template<typename T> struct RemovePointer<T*> {
58             typedef T Type;
59         };
60
61         template<typename T> struct RemovePointer<RefPtr<T>> {
62             typedef T Type;
63         };
64
65         template<typename T> struct RemovePointer<PassRefPtr<T>> {
66             typedef T Type;
67         };
68
69         template<typename T> struct IsConvertibleToInteger {
70             static const bool value = std::is_integral<T>::value || std::is_convertible<T, long double>::value;
71         };
72
73         template<typename T> struct IsThreadSafeRefCountedPointer {
74             static const bool value = std::is_convertible<typename RemovePointer<T>::Type*, ThreadSafeRefCounted<typename RemovePointer<T>::Type>*>::value;
75         };
76     };
77
78     template<typename T> struct CrossThreadCopierPassThrough {
79         typedef T Type;
80         static Type copy(const T& parameter)
81         {
82             return parameter;
83         }
84     };
85
86     template<bool isConvertibleToInteger, bool isThreadSafeRefCounted, typename T> struct CrossThreadCopierBase;
87
88     // Integers get passed through without any changes.
89     template<typename T> struct CrossThreadCopierBase<true, false, T> : public CrossThreadCopierPassThrough<T> {
90     };
91
92     // To allow a type to be passed across threads using its copy constructor, add a forward declaration of the type and
93     // a CopyThreadCopierBase<false, false, TypeName> : public CrossThreadCopierPassThrough<TypeName> { }; to this file.
94     template<> struct CrossThreadCopierBase<false, false, ThreadableLoaderOptions> : public CrossThreadCopierPassThrough<ThreadableLoaderOptions> {
95     };
96
97     template<> struct CrossThreadCopierBase<false, false, IntRect> : public CrossThreadCopierPassThrough<IntRect> {
98     };
99
100     template<> struct CrossThreadCopierBase<false, false, IntSize> : public CrossThreadCopierPassThrough<IntSize> {
101     };
102
103     // Custom copy methods.
104     template<typename T> struct CrossThreadCopierBase<false, true, T> {
105         typedef typename CrossThreadCopierBaseHelper::RemovePointer<T>::Type RefCountedType;
106         static_assert(std::is_convertible<RefCountedType*, ThreadSafeRefCounted<RefCountedType>*>::value, "T is not convertible to ThreadSafeRefCounted!");
107
108         typedef PassRefPtr<RefCountedType> Type;
109         static Type copy(const T& refPtr)
110         {
111             return refPtr;
112         }
113     };
114
115     template<typename T> struct CrossThreadCopierBase<false, false, PassOwnPtr<T>> {
116         typedef PassOwnPtr<T> Type;
117         static Type copy(Type ownPtr)
118         {
119             return ownPtr;
120         }
121     };
122
123     template<> struct CrossThreadCopierBase<false, false, URL> {
124         typedef URL Type;
125         static Type copy(const URL&);
126     };
127
128     template<> struct CrossThreadCopierBase<false, false, String> {
129         typedef String Type;
130         static Type copy(const String&);
131     };
132
133     template<> struct CrossThreadCopierBase<false, false, ResourceError> {
134         typedef ResourceError Type;
135         static Type copy(const ResourceError&);
136     };
137
138     template<> struct CrossThreadCopierBase<false, false, ResourceRequest> {
139         typedef PassOwnPtr<CrossThreadResourceRequestData> Type;
140         static Type copy(const ResourceRequest&);
141     };
142
143     template<> struct CrossThreadCopierBase<false, false, ResourceResponse> {
144         typedef PassOwnPtr<CrossThreadResourceResponseData> Type;
145         static Type copy(const ResourceResponse&);
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         static IndexedDB::TransactionMode copy(const IndexedDB::TransactionMode&);
156     };
157     template<> struct CrossThreadCopierBase<false, false, IndexedDB::CursorDirection> {
158         static IndexedDB::CursorDirection copy(const IndexedDB::CursorDirection&);
159     };
160     template<> struct CrossThreadCopierBase<false, false, IndexedDB::CursorType> {
161         static IndexedDB::CursorType copy(const IndexedDB::CursorType&);
162     };
163
164     struct IDBDatabaseMetadata;
165     template<> struct CrossThreadCopierBase<false, false, IDBDatabaseMetadata> {
166         typedef IDBDatabaseMetadata Type;
167         static Type copy(const IDBDatabaseMetadata&);
168     };
169
170     struct IDBGetResult;
171     template<> struct CrossThreadCopierBase<false, false, IDBGetResult> {
172         typedef IDBGetResult Type;
173         static Type copy(const IDBGetResult&);
174     };
175
176     struct IDBIndexMetadata;
177     template<> struct CrossThreadCopierBase<false, false, IDBIndexMetadata> {
178         typedef IDBIndexMetadata Type;
179         static Type copy(const IDBIndexMetadata&);
180     };
181
182     struct IDBKeyData;
183     template<> struct CrossThreadCopierBase<false, false, IDBKeyData> {
184         typedef IDBKeyData Type;
185         static Type copy(const IDBKeyData&);
186     };
187
188     struct IDBKeyRangeData;
189     template<> struct CrossThreadCopierBase<false, false, IDBKeyRangeData> {
190         typedef IDBKeyRangeData Type;
191         static Type copy(const IDBKeyRangeData&);
192     };
193
194     struct IDBObjectStoreMetadata;
195     template<> struct CrossThreadCopierBase<false, false, IDBObjectStoreMetadata> {
196         typedef IDBObjectStoreMetadata Type;
197         static Type copy(const IDBObjectStoreMetadata&);
198     };
199 #endif
200
201     template<typename T>
202     struct CrossThreadCopier : public CrossThreadCopierBase<CrossThreadCopierBaseHelper::IsConvertibleToInteger<T>::value, CrossThreadCopierBaseHelper::IsThreadSafeRefCountedPointer<T>::value, T> {
203     };
204
205     template<typename T> struct AllowCrossThreadAccessWrapper {
206     public:
207         explicit AllowCrossThreadAccessWrapper(T* value) : m_value(value) { }
208         T* value() const { return m_value; }
209     private:
210         T* m_value;
211     };
212
213     template<typename T> struct CrossThreadCopierBase<false, false, AllowCrossThreadAccessWrapper<T>> {
214         typedef T* Type;
215         static Type copy(const AllowCrossThreadAccessWrapper<T>& wrapper) { return wrapper.value(); }
216     };
217
218     template<typename T> AllowCrossThreadAccessWrapper<T> AllowCrossThreadAccess(T* value) 
219     {
220         return AllowCrossThreadAccessWrapper<T>(value);
221     }
222
223     // FIXME: Move to a different header file. AllowAccessLater is for cross-thread access
224     // that is not cross-thread (tasks posted to a queue guaranteed to run on the same thread).
225     template<typename T> struct AllowAccessLaterWrapper {
226     public:
227         explicit AllowAccessLaterWrapper(T* value) : m_value(value) { }
228         T* value() const { return m_value; }
229     private:
230         T* m_value;
231     };
232
233     template<typename T> struct CrossThreadCopierBase<false, false, AllowAccessLaterWrapper<T>> {
234         typedef T* Type;
235         static Type copy(const AllowAccessLaterWrapper<T>& wrapper) { return wrapper.value(); }
236     };
237
238     template<typename T> AllowAccessLaterWrapper<T> AllowAccessLater(T* value)
239     {
240         return AllowAccessLaterWrapper<T>(value);
241     }
242
243
244 } // namespace WebCore
245
246 #endif // CrossThreadCopier_h