Remove excessive headers from WebCore/{bindings,css,dom}
[WebKit-https.git] / Source / WebCore / bindings / js / JSDOMConvertBufferSource.h
1 /*
2  * Copyright (C) 2016 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 "BufferSource.h"
29 #include "IDLTypes.h"
30 #include "JSDOMConvertBase.h"
31 #include "JSDOMWrapperCache.h"
32 #include "JSDynamicDowncast.h"
33 #include <runtime/JSTypedArrays.h>
34
35 namespace WebCore {
36
37 struct IDLInt8Array : IDLTypedArray<JSC::Int8Array> { };
38 struct IDLInt16Array : IDLTypedArray<JSC::Int16Array> { };
39 struct IDLInt32Array : IDLTypedArray<JSC::Int32Array> { };
40 struct IDLUint8Array : IDLTypedArray<JSC::Uint8Array> { };
41 struct IDLUint16Array : IDLTypedArray<JSC::Uint16Array> { };
42 struct IDLUint32Array : IDLTypedArray<JSC::Uint32Array> { };
43 struct IDLUint8ClampedArray : IDLTypedArray<JSC::Uint8ClampedArray> { };
44 struct IDLFloat32Array : IDLTypedArray<JSC::Float32Array> { };
45 struct IDLFloat64Array : IDLTypedArray<JSC::Float64Array> { };
46
47 inline RefPtr<JSC::Int8Array> toPossiblySharedInt8Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toPossiblySharedNativeTypedView<JSC::Int8Adaptor>(vm, value); }
48 inline RefPtr<JSC::Int16Array> toPossiblySharedInt16Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toPossiblySharedNativeTypedView<JSC::Int16Adaptor>(vm, value); }
49 inline RefPtr<JSC::Int32Array> toPossiblySharedInt32Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toPossiblySharedNativeTypedView<JSC::Int32Adaptor>(vm, value); }
50 inline RefPtr<JSC::Uint8Array> toPossiblySharedUint8Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toPossiblySharedNativeTypedView<JSC::Uint8Adaptor>(vm, value); }
51 inline RefPtr<JSC::Uint8ClampedArray> toPossiblySharedUint8ClampedArray(JSC::VM& vm, JSC::JSValue value) { return JSC::toPossiblySharedNativeTypedView<JSC::Uint8ClampedAdaptor>(vm, value); }
52 inline RefPtr<JSC::Uint16Array> toPossiblySharedUint16Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toPossiblySharedNativeTypedView<JSC::Uint16Adaptor>(vm, value); }
53 inline RefPtr<JSC::Uint32Array> toPossiblySharedUint32Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toPossiblySharedNativeTypedView<JSC::Uint32Adaptor>(vm, value); }
54 inline RefPtr<JSC::Float32Array> toPossiblySharedFloat32Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toPossiblySharedNativeTypedView<JSC::Float32Adaptor>(vm, value); }
55 inline RefPtr<JSC::Float64Array> toPossiblySharedFloat64Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toPossiblySharedNativeTypedView<JSC::Float64Adaptor>(vm, value); }
56
57 inline RefPtr<JSC::Int8Array> toUnsharedInt8Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toUnsharedNativeTypedView<JSC::Int8Adaptor>(vm, value); }
58 inline RefPtr<JSC::Int16Array> toUnsharedInt16Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toUnsharedNativeTypedView<JSC::Int16Adaptor>(vm, value); }
59 inline RefPtr<JSC::Int32Array> toUnsharedInt32Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toUnsharedNativeTypedView<JSC::Int32Adaptor>(vm, value); }
60 inline RefPtr<JSC::Uint8Array> toUnsharedUint8Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toUnsharedNativeTypedView<JSC::Uint8Adaptor>(vm, value); }
61 inline RefPtr<JSC::Uint8ClampedArray> toUnsharedUint8ClampedArray(JSC::VM& vm, JSC::JSValue value) { return JSC::toUnsharedNativeTypedView<JSC::Uint8ClampedAdaptor>(vm, value); }
62 inline RefPtr<JSC::Uint16Array> toUnsharedUint16Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toUnsharedNativeTypedView<JSC::Uint16Adaptor>(vm, value); }
63 inline RefPtr<JSC::Uint32Array> toUnsharedUint32Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toUnsharedNativeTypedView<JSC::Uint32Adaptor>(vm, value); }
64 inline RefPtr<JSC::Float32Array> toUnsharedFloat32Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toUnsharedNativeTypedView<JSC::Float32Adaptor>(vm, value); }
65 inline RefPtr<JSC::Float64Array> toUnsharedFloat64Array(JSC::VM& vm, JSC::JSValue value) { return JSC::toUnsharedNativeTypedView<JSC::Float64Adaptor>(vm, value); }
66
67 inline JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, JSC::ArrayBuffer& buffer)
68 {
69     if (auto result = getCachedWrapper(globalObject->world(), buffer))
70         return result;
71
72     // The JSArrayBuffer::create function will register the wrapper in finishCreation.
73     return JSC::JSArrayBuffer::create(state->vm(), globalObject->arrayBufferStructure(buffer.sharingMode()), &buffer);
74 }
75
76 inline JSC::JSValue toJS(JSC::ExecState* state, JSC::JSGlobalObject* globalObject, JSC::ArrayBufferView& view)
77 {
78     return view.wrap(state, globalObject);
79 }
80
81 inline JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, JSC::ArrayBuffer* buffer)
82 {
83     if (!buffer)
84         return JSC::jsNull();
85     return toJS(state, globalObject, *buffer);
86 }
87
88 inline JSC::JSValue toJS(JSC::ExecState* state, JSC::JSGlobalObject* globalObject, JSC::ArrayBufferView* view)
89 {
90     if (!view)
91         return JSC::jsNull();
92     return toJS(state, globalObject, *view);
93 }
94
95 inline RefPtr<JSC::ArrayBufferView> toPossiblySharedArrayBufferView(JSC::VM& vm, JSC::JSValue value)
96 {
97     auto* wrapper = jsDynamicDowncast<JSC::JSArrayBufferView*>(vm, value);
98     if (!wrapper)
99         return nullptr;
100     return wrapper->possiblySharedImpl();
101 }
102
103 inline RefPtr<JSC::ArrayBufferView> toUnsharedArrayBufferView(JSC::VM& vm, JSC::JSValue value)
104 {
105     auto result = toPossiblySharedArrayBufferView(vm, value);
106     if (!result || result->isShared())
107         return nullptr;
108     return result;
109 }
110
111 namespace Detail {
112
113 template<typename BufferSourceType>
114 struct BufferSourceConverter {
115     using WrapperType = typename Converter<BufferSourceType>::WrapperType;
116     using ReturnType = typename Converter<BufferSourceType>::ReturnType;
117
118     template<typename ExceptionThrower = DefaultExceptionThrower>
119     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
120     {
121         auto& vm = state.vm();
122         auto scope = DECLARE_THROW_SCOPE(vm);
123         ReturnType object = WrapperType::toWrapped(vm, value);
124         if (UNLIKELY(!object))
125             exceptionThrower(state, scope);
126         return object;
127     }
128 };
129
130 }
131
132 template<> struct Converter<IDLArrayBuffer> : DefaultConverter<IDLArrayBuffer> {
133     using WrapperType = JSC::JSArrayBuffer;
134     using ReturnType = JSC::ArrayBuffer*;
135
136     template<typename ExceptionThrower = DefaultExceptionThrower>
137     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
138     {
139         return Detail::BufferSourceConverter<IDLArrayBuffer>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
140     }
141 };
142
143 template<> struct JSConverter<IDLArrayBuffer> {
144     static constexpr bool needsState = true;
145     static constexpr bool needsGlobalObject = true;
146
147     template <typename U>
148     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
149     {
150         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
151     }
152 };
153
154 template<> struct Converter<IDLDataView> : DefaultConverter<IDLDataView> {
155     using WrapperType = JSC::JSDataView;
156     using ReturnType = RefPtr<JSC::DataView>;
157
158     template<typename ExceptionThrower = DefaultExceptionThrower>
159     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
160     {
161         return Detail::BufferSourceConverter<IDLDataView>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
162     }
163 };
164
165 template<> struct JSConverter<IDLDataView> {
166     static constexpr bool needsState = true;
167     static constexpr bool needsGlobalObject = true;
168
169     template <typename U>
170     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
171     {
172         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
173     }
174 };
175
176 template<> struct Converter<IDLInt8Array> : DefaultConverter<IDLInt8Array> {
177     using WrapperType = JSC::JSInt8Array;
178     using ReturnType = RefPtr<JSC::Int8Array>;
179
180     template<typename ExceptionThrower = DefaultExceptionThrower>
181     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
182     {
183         return Detail::BufferSourceConverter<IDLInt8Array>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
184     }
185 };
186
187 template<> struct JSConverter<IDLInt8Array> {
188     static constexpr bool needsState = true;
189     static constexpr bool needsGlobalObject = true;
190
191     template <typename U>
192     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
193     {
194         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
195     }
196 };
197
198 template<> struct Converter<IDLInt16Array> : DefaultConverter<IDLInt16Array> {
199     using WrapperType = JSC::JSInt16Array;
200     using ReturnType = RefPtr<JSC::Int16Array>;
201
202     template<typename ExceptionThrower = DefaultExceptionThrower>
203     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
204     {
205         return Detail::BufferSourceConverter<IDLInt16Array>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
206     }
207 };
208
209 template<> struct JSConverter<IDLInt16Array> {
210     static constexpr bool needsState = true;
211     static constexpr bool needsGlobalObject = true;
212
213     template <typename U>
214     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
215     {
216         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
217     }
218 };
219
220 template<> struct Converter<IDLInt32Array> : DefaultConverter<IDLInt32Array> {
221     using WrapperType = JSC::JSInt32Array;
222     using ReturnType = RefPtr<JSC::Int32Array>;
223
224     template<typename ExceptionThrower = DefaultExceptionThrower>
225     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
226     {
227         return Detail::BufferSourceConverter<IDLInt32Array>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
228     }
229 };
230
231 template<> struct JSConverter<IDLInt32Array> {
232     static constexpr bool needsState = true;
233     static constexpr bool needsGlobalObject = true;
234
235     template <typename U>
236     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
237     {
238         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
239     }
240 };
241
242 template<> struct Converter<IDLUint8Array> : DefaultConverter<IDLUint8Array> {
243     using WrapperType = JSC::JSUint8Array;
244     using ReturnType = RefPtr<JSC::Uint8Array>;
245
246     template<typename ExceptionThrower = DefaultExceptionThrower>
247     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
248     {
249         return Detail::BufferSourceConverter<IDLUint8Array>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
250     }
251 };
252
253 template<> struct JSConverter<IDLUint8Array> {
254     static constexpr bool needsState = true;
255     static constexpr bool needsGlobalObject = true;
256
257     template <typename U>
258     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
259     {
260         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
261     }
262 };
263
264 template<> struct Converter<IDLUint16Array> : DefaultConverter<IDLUint16Array> {
265     using WrapperType = JSC::JSUint16Array;
266     using ReturnType = RefPtr<JSC::Uint16Array>;
267
268     template<typename ExceptionThrower = DefaultExceptionThrower>
269     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
270     {
271         return Detail::BufferSourceConverter<IDLUint16Array>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
272     }
273 };
274
275 template<> struct JSConverter<IDLUint16Array> {
276     static constexpr bool needsState = true;
277     static constexpr bool needsGlobalObject = true;
278
279     template <typename U>
280     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
281     {
282         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
283     }
284 };
285
286 template<> struct Converter<IDLUint32Array> : DefaultConverter<IDLUint32Array> {
287     using WrapperType = JSC::JSUint32Array;
288     using ReturnType = RefPtr<JSC::Uint32Array>;
289
290     template<typename ExceptionThrower = DefaultExceptionThrower>
291     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
292     {
293         return Detail::BufferSourceConverter<IDLUint32Array>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
294     }
295 };
296
297 template<> struct JSConverter<IDLUint32Array> {
298     static constexpr bool needsState = true;
299     static constexpr bool needsGlobalObject = true;
300
301     template <typename U>
302     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
303     {
304         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
305     }
306 };
307
308 template<> struct Converter<IDLUint8ClampedArray> : DefaultConverter<IDLUint8ClampedArray> {
309     using WrapperType = JSC::JSUint8ClampedArray;
310     using ReturnType = RefPtr<JSC::Uint8ClampedArray>;
311
312     template<typename ExceptionThrower = DefaultExceptionThrower>
313     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
314     {
315         return Detail::BufferSourceConverter<IDLUint8ClampedArray>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
316     }
317 };
318
319 template<> struct JSConverter<IDLUint8ClampedArray> {
320     static constexpr bool needsState = true;
321     static constexpr bool needsGlobalObject = true;
322
323     template <typename U>
324     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
325     {
326         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
327     }
328 };
329
330 template<> struct Converter<IDLFloat32Array> : DefaultConverter<IDLFloat32Array> {
331     using WrapperType = JSC::JSFloat32Array;
332     using ReturnType = RefPtr<JSC::Float32Array>;
333
334     template<typename ExceptionThrower = DefaultExceptionThrower>
335     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
336     {
337         return Detail::BufferSourceConverter<IDLFloat32Array>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
338     }
339 };
340
341 template<> struct JSConverter<IDLFloat32Array> {
342     static constexpr bool needsState = true;
343     static constexpr bool needsGlobalObject = true;
344
345     template <typename U>
346     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
347     {
348         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
349     }
350 };
351
352 template<> struct Converter<IDLFloat64Array> : DefaultConverter<IDLFloat64Array> {
353     using WrapperType = JSC::JSFloat64Array;
354     using ReturnType = RefPtr<JSC::Float64Array>;
355
356     template<typename ExceptionThrower = DefaultExceptionThrower>
357     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
358     {
359         return Detail::BufferSourceConverter<IDLFloat64Array>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
360     }
361 };
362
363 template<> struct JSConverter<IDLFloat64Array> {
364     static constexpr bool needsState = true;
365     static constexpr bool needsGlobalObject = true;
366
367     template <typename U>
368     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
369     {
370         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
371     }
372 };
373
374 template<> struct Converter<IDLArrayBufferView> : DefaultConverter<IDLArrayBufferView> {
375     using WrapperType = JSC::JSArrayBufferView;
376     using ReturnType = RefPtr<JSC::ArrayBufferView>;
377
378     template<typename ExceptionThrower = DefaultExceptionThrower>
379     static ReturnType convert(JSC::ExecState& state, JSC::JSValue value, ExceptionThrower&& exceptionThrower = ExceptionThrower())
380     {
381         return Detail::BufferSourceConverter<IDLArrayBufferView>::convert(state, value, std::forward<ExceptionThrower>(exceptionThrower));
382     }
383 };
384
385 template<> struct JSConverter<IDLArrayBufferView> {
386     static constexpr bool needsState = true;
387     static constexpr bool needsGlobalObject = true;
388
389     template <typename U>
390     static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const U& value)
391     {
392         return toJS(&state, &globalObject, Detail::getPtrOrRef(value));
393     }
394 };
395
396 } // namespace WebCore