DOMMatrix and DOMMatrixReadOnly should be available in workers
[WebKit-https.git] / Source / WebCore / css / DOMMatrixReadOnly.cpp
1 /*
2  * Copyright (C) 2017 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 #include "config.h"
27 #include "DOMMatrixReadOnly.h"
28
29 #include "CSSParser.h"
30 #include "CSSToLengthConversionData.h"
31 #include "DOMMatrix.h"
32 #include "DOMPoint.h"
33 #include "ScriptExecutionContext.h"
34 #include "StyleProperties.h"
35 #include "TransformFunctions.h"
36 #include <JavaScriptCore/GenericTypedArrayViewInlines.h>
37 #include <JavaScriptCore/JSGenericTypedArrayViewInlines.h>
38 #include <heap/HeapInlines.h>
39 #include <wtf/text/StringBuilder.h>
40
41 namespace WebCore {
42
43 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-dommatrixreadonly
44 ExceptionOr<Ref<DOMMatrixReadOnly>> DOMMatrixReadOnly::create(ScriptExecutionContext& scriptExecutionContext, std::optional<Variant<String, Vector<double>>>&& init)
45 {
46     if (!init)
47         return adoptRef(*new DOMMatrixReadOnly);
48
49     return WTF::switchOn(init.value(),
50         [&scriptExecutionContext](const String& init) -> ExceptionOr<Ref<DOMMatrixReadOnly>> {
51             if (!scriptExecutionContext.isDocument())
52                 return Exception { TypeError };
53
54             auto parseResult = parseStringIntoAbstractMatrix(init);
55             if (parseResult.hasException())
56                 return parseResult.releaseException();
57             
58             return adoptRef(*new DOMMatrixReadOnly(parseResult.returnValue().matrix, parseResult.returnValue().is2D ? Is2D::Yes : Is2D::No));
59         },
60         [](const Vector<double>& init) -> ExceptionOr<Ref<DOMMatrixReadOnly>> {
61             if (init.size() == 6) {
62                 return adoptRef(*new DOMMatrixReadOnly(TransformationMatrix {
63                     init[0], init[1], init[2], init[3], init[4], init[5]
64                 }, Is2D::Yes));
65             }
66             if (init.size() == 16) {
67                 return adoptRef(*new DOMMatrixReadOnly(TransformationMatrix {
68                     init[0], init[1], init[2], init[3],
69                     init[4], init[5], init[6], init[7],
70                     init[8], init[9], init[10], init[11],
71                     init[12], init[13], init[14], init[15]
72                 }, Is2D::No));
73             }
74             return Exception { TypeError };
75         }
76     );
77 }
78
79 DOMMatrixReadOnly::DOMMatrixReadOnly(const TransformationMatrix& matrix, Is2D is2D)
80     : m_matrix(matrix)
81     , m_is2D(is2D == Is2D::Yes)
82 {
83     ASSERT(!m_is2D || m_matrix.isAffine());
84 }
85
86 DOMMatrixReadOnly::DOMMatrixReadOnly(TransformationMatrix&& matrix, Is2D is2D)
87     : m_matrix(WTFMove(matrix))
88     , m_is2D(is2D == Is2D::Yes)
89 {
90     ASSERT(!m_is2D || m_matrix.isAffine());
91 }
92
93 inline Ref<DOMMatrix> DOMMatrixReadOnly::cloneAsDOMMatrix() const
94 {
95     return DOMMatrix::create(m_matrix, m_is2D ? Is2D::Yes : Is2D::No);
96 }
97
98 // https://drafts.fxtf.org/geometry/#matrix-validate-and-fixup
99 ExceptionOr<void> DOMMatrixReadOnly::validateAndFixup(DOMMatrix2DInit& init)
100 {
101     // FIXME: Should be using SameValueZero rather than c-equality.
102     if (init.a && init.m11 && init.a.value() != init.m11.value())
103         return Exception { TypeError, ASCIILiteral("init.a and init.m11 do not match") };
104     if (init.b && init.m12 && init.b.value() != init.m12.value())
105         return Exception { TypeError, ASCIILiteral("init.b and init.m12 do not match") };
106     if (init.c && init.m21 && init.c.value() != init.m21.value())
107         return Exception { TypeError, ASCIILiteral("init.c and init.m21 do not match") };
108     if (init.d && init.m22 && init.d.value() != init.m22.value())
109         return Exception { TypeError, ASCIILiteral("init.d and init.m22 do not match") };
110     if (init.e && init.m41 && init.e.value() != init.m41.value())
111         return Exception { TypeError, ASCIILiteral("init.e and init.m41 do not match") };
112     if (init.f && init.m42 && init.f.value() != init.m42.value())
113         return Exception { TypeError, ASCIILiteral("init.f and init.m42 do not match") };
114
115     if (!init.m11)
116         init.m11 = init.a.value_or(1);
117     if (!init.m12)
118         init.m12 = init.b.value_or(0);
119     if (!init.m21)
120         init.m21 = init.c.value_or(0);
121     if (!init.m22)
122         init.m22 = init.d.value_or(1);
123     if (!init.m41)
124         init.m41 = init.e.value_or(0);
125     if (!init.m42)
126         init.m42 = init.f.value_or(0);
127
128     return { };
129 }
130
131 ExceptionOr<void> DOMMatrixReadOnly::validateAndFixup(DOMMatrixInit& init)
132 {
133     auto validate2D = validateAndFixup(static_cast<DOMMatrix2DInit&>(init));
134     if (validate2D.hasException())
135         return validate2D.releaseException();
136
137     if (init.is2D && init.is2D.value()) {
138         if (init.m13)
139             return Exception { TypeError, ASCIILiteral("m13 should be 0 for a 2D matrix") };
140         if (init.m14)
141             return Exception { TypeError, ASCIILiteral("m14 should be 0 for a 2D matrix") };
142         if (init.m23)
143             return Exception { TypeError, ASCIILiteral("m23 should be 0 for a 2D matrix") };
144         if (init.m24)
145             return Exception { TypeError, ASCIILiteral("m24 should be 0 for a 2D matrix") };
146         if (init.m31)
147             return Exception { TypeError, ASCIILiteral("m31 should be 0 for a 2D matrix") };
148         if (init.m32)
149             return Exception { TypeError, ASCIILiteral("m32 should be 0 for a 2D matrix") };
150         if (init.m34)
151             return Exception { TypeError, ASCIILiteral("m34 should be 0 for a 2D matrix") };
152         if (init.m43)
153             return Exception { TypeError, ASCIILiteral("m43 should be 0 for a 2D matrix") };
154         if (init.m33 != 1)
155             return Exception { TypeError, ASCIILiteral("m33 should be 1 for a 2D matrix") };
156         if (init.m44 != 1)
157             return Exception { TypeError, ASCIILiteral("m44 should be 1 for a 2D matrix") };
158     }
159
160     if (!init.is2D) {
161         if (init.m13 || init.m14 || init.m23 || init.m24 || init.m31 || init.m32 || init.m34 || init.m43 || init.m33 != 1 || init.m44 != 1)
162             init.is2D = false;
163         else
164             init.is2D = true;
165     }
166     return { };
167 }
168
169 ExceptionOr<Ref<DOMMatrixReadOnly>> DOMMatrixReadOnly::fromMatrix(DOMMatrixInit&& init)
170 {
171     return fromMatrixHelper<DOMMatrixReadOnly>(WTFMove(init));
172 }
173
174 ExceptionOr<Ref<DOMMatrixReadOnly>> DOMMatrixReadOnly::fromFloat32Array(Ref<Float32Array>&& array32)
175 {
176     if (array32->length() == 6)
177         return DOMMatrixReadOnly::create(TransformationMatrix(array32->item(0), array32->item(1), array32->item(2), array32->item(3), array32->item(4), array32->item(5)), Is2D::Yes);
178
179     if (array32->length() == 16) {
180         return DOMMatrixReadOnly::create(TransformationMatrix(
181             array32->item(0), array32->item(1), array32->item(2), array32->item(3),
182             array32->item(4), array32->item(5), array32->item(6), array32->item(7),
183             array32->item(8), array32->item(9), array32->item(10), array32->item(11),
184             array32->item(12), array32->item(13), array32->item(14), array32->item(15)
185         ), Is2D::No);
186     }
187
188     return Exception { TypeError };
189 }
190
191 ExceptionOr<Ref<DOMMatrixReadOnly>> DOMMatrixReadOnly::fromFloat64Array(Ref<Float64Array>&& array64)
192 {
193     if (array64->length() == 6)
194         return DOMMatrixReadOnly::create(TransformationMatrix(array64->item(0), array64->item(1), array64->item(2), array64->item(3), array64->item(4), array64->item(5)), Is2D::Yes);
195
196     if (array64->length() == 16) {
197         return DOMMatrixReadOnly::create(TransformationMatrix(
198             array64->item(0), array64->item(1), array64->item(2), array64->item(3),
199             array64->item(4), array64->item(5), array64->item(6), array64->item(7),
200             array64->item(8), array64->item(9), array64->item(10), array64->item(11),
201             array64->item(12), array64->item(13), array64->item(14), array64->item(15)
202         ), Is2D::No);
203     }
204
205     return Exception { TypeError };
206 }
207
208 bool DOMMatrixReadOnly::isIdentity() const
209 {
210     return m_matrix.isIdentity();
211 }
212
213 ExceptionOr<DOMMatrixReadOnly::AbstractMatrix> DOMMatrixReadOnly::parseStringIntoAbstractMatrix(const String& string)
214 {
215     if (string.isEmpty())
216         return AbstractMatrix { };
217
218     auto styleDeclaration = MutableStyleProperties::create();
219     if (CSSParser::parseValue(styleDeclaration, CSSPropertyTransform, string, true, HTMLStandardMode) == CSSParser::ParseResult::Error)
220         return Exception { SyntaxError };
221
222     // Convert to TransformOperations. This can fail if a property requires style (i.e., param uses 'ems' or 'exs')
223     auto value = styleDeclaration->getPropertyCSSValue(CSSPropertyTransform);
224
225     // Check for a "none" or empty transform. In these cases we can use the default identity matrix.
226     if (!value || (is<CSSPrimitiveValue>(*value) && downcast<CSSPrimitiveValue>(*value).valueID() == CSSValueNone))
227         return AbstractMatrix { };
228
229     TransformOperations operations;
230     if (!transformsForValue(*value, CSSToLengthConversionData(), operations))
231         return Exception { SyntaxError };
232
233     AbstractMatrix matrix;
234     for (auto& operation : operations.operations()) {
235         if (operation->apply(matrix.matrix, { 0, 0 }))
236             return Exception { SyntaxError };
237         if (operation->is3DOperation())
238             matrix.is2D = false;
239     }
240
241     return WTFMove(matrix);
242 }
243
244 // https://drafts.fxtf.org/geometry/#dom-dommatrix-setmatrixvalue
245 ExceptionOr<void> DOMMatrixReadOnly::setMatrixValue(const String& string)
246 {
247     auto parseResult = parseStringIntoAbstractMatrix(string);
248     if (parseResult.hasException())
249         return parseResult.releaseException();
250
251     m_is2D = parseResult.returnValue().is2D;
252     m_matrix = parseResult.returnValue().matrix;
253     return { };
254 }
255
256 Ref<DOMMatrix> DOMMatrixReadOnly::translate(double tx, double ty, double tz)
257 {
258     auto matrix = cloneAsDOMMatrix();
259     return matrix->translateSelf(tx, ty, tz);
260 }
261
262 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-flipx
263 Ref<DOMMatrix> DOMMatrixReadOnly::flipX()
264 {
265     auto matrix = cloneAsDOMMatrix();
266     matrix->m_matrix.flipX();
267     return matrix;
268 }
269
270 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-flipy
271 Ref<DOMMatrix> DOMMatrixReadOnly::flipY()
272 {
273     auto matrix = cloneAsDOMMatrix();
274     matrix->m_matrix.flipY();
275     return matrix;
276 }
277
278 ExceptionOr<Ref<DOMMatrix>> DOMMatrixReadOnly::multiply(DOMMatrixInit&& other) const
279 {
280     auto matrix = cloneAsDOMMatrix();
281     return matrix->multiplySelf(WTFMove(other));
282 }
283
284 Ref<DOMMatrix> DOMMatrixReadOnly::scale(double scaleX, std::optional<double> scaleY, double scaleZ, double originX, double originY, double originZ)
285 {
286     auto matrix = cloneAsDOMMatrix();
287     return matrix->scaleSelf(scaleX, scaleY, scaleZ, originX, originY, originZ);
288 }
289
290 Ref<DOMMatrix> DOMMatrixReadOnly::scale3d(double scale, double originX, double originY, double originZ)
291 {
292     auto matrix = cloneAsDOMMatrix();
293     return matrix->scale3dSelf(scale, originX, originY, originZ);
294 }
295
296 Ref<DOMMatrix> DOMMatrixReadOnly::rotate(double rotX, std::optional<double> rotY, std::optional<double> rotZ)
297 {
298     auto matrix = cloneAsDOMMatrix();
299     return matrix->rotateSelf(rotX, rotY, rotZ);
300 }
301
302 Ref<DOMMatrix> DOMMatrixReadOnly::rotateFromVector(double x, double y)
303 {
304     auto matrix = cloneAsDOMMatrix();
305     return matrix->rotateFromVectorSelf(x, y);
306 }
307
308 Ref<DOMMatrix> DOMMatrixReadOnly::rotateAxisAngle(double x, double y, double z, double angle)
309 {
310     auto matrix = cloneAsDOMMatrix();
311     return matrix->rotateAxisAngleSelf(x, y, z, angle);
312 }
313
314 Ref<DOMMatrix> DOMMatrixReadOnly::skewX(double sx)
315 {
316     auto matrix = cloneAsDOMMatrix();
317     return matrix->skewXSelf(sx);
318 }
319
320 Ref<DOMMatrix> DOMMatrixReadOnly::skewY(double sy)
321 {
322     auto matrix = cloneAsDOMMatrix();
323     return matrix->skewYSelf(sy);
324 }
325
326 Ref<DOMMatrix> DOMMatrixReadOnly::inverse() const
327 {
328     auto matrix = cloneAsDOMMatrix();
329     return matrix->invertSelf();
330 }
331
332 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-transformpoint
333 Ref<DOMPoint> DOMMatrixReadOnly::transformPoint(DOMPointInit&& pointInit)
334 {
335     m_matrix.map4ComponentPoint(pointInit.x, pointInit.y, pointInit.z, pointInit.w);
336     return DOMPoint::create(pointInit.x, pointInit.y, pointInit.z, pointInit.w);
337 }
338
339 ExceptionOr<Ref<Float32Array>> DOMMatrixReadOnly::toFloat32Array() const
340 {
341     auto array32 = Float32Array::createUninitialized(16);
342     if (!array32)
343         return Exception { UnknownError, ASCIILiteral("Out of memory") };
344
345     unsigned index = 0;
346     array32->set(index++, m_matrix.m11());
347     array32->set(index++, m_matrix.m12());
348     array32->set(index++, m_matrix.m13());
349     array32->set(index++, m_matrix.m14());
350     array32->set(index++, m_matrix.m21());
351     array32->set(index++, m_matrix.m22());
352     array32->set(index++, m_matrix.m23());
353     array32->set(index++, m_matrix.m24());
354     array32->set(index++, m_matrix.m31());
355     array32->set(index++, m_matrix.m32());
356     array32->set(index++, m_matrix.m33());
357     array32->set(index++, m_matrix.m34());
358     array32->set(index++, m_matrix.m41());
359     array32->set(index++, m_matrix.m42());
360     array32->set(index++, m_matrix.m43());
361     array32->set(index, m_matrix.m44());
362     return array32.releaseNonNull();
363 }
364
365 ExceptionOr<Ref<Float64Array>> DOMMatrixReadOnly::toFloat64Array() const
366 {
367     auto array64 = Float64Array::createUninitialized(16);
368     if (!array64)
369         return Exception { UnknownError, ASCIILiteral("Out of memory") };
370
371     unsigned index = 0;
372     array64->set(index++, m_matrix.m11());
373     array64->set(index++, m_matrix.m12());
374     array64->set(index++, m_matrix.m13());
375     array64->set(index++, m_matrix.m14());
376     array64->set(index++, m_matrix.m21());
377     array64->set(index++, m_matrix.m22());
378     array64->set(index++, m_matrix.m23());
379     array64->set(index++, m_matrix.m24());
380     array64->set(index++, m_matrix.m31());
381     array64->set(index++, m_matrix.m32());
382     array64->set(index++, m_matrix.m33());
383     array64->set(index++, m_matrix.m34());
384     array64->set(index++, m_matrix.m41());
385     array64->set(index++, m_matrix.m42());
386     array64->set(index++, m_matrix.m43());
387     array64->set(index, m_matrix.m44());
388     return array64.releaseNonNull();
389 }
390
391 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-stringifier
392 ExceptionOr<String> DOMMatrixReadOnly::toString() const
393 {
394     if (!m_matrix.containsOnlyFiniteValues())
395         return Exception { InvalidStateError, ASCIILiteral("Matrix contains non-finite values") };
396
397     StringBuilder builder;
398     if (is2D()) {
399         builder.appendLiteral("matrix(");
400         builder.append(String::numberToStringECMAScript(m_matrix.a()));
401         builder.appendLiteral(", ");
402         builder.append(String::numberToStringECMAScript(m_matrix.b()));
403         builder.appendLiteral(", ");
404         builder.append(String::numberToStringECMAScript(m_matrix.c()));
405         builder.appendLiteral(", ");
406         builder.append(String::numberToStringECMAScript(m_matrix.d()));
407         builder.appendLiteral(", ");
408         builder.append(String::numberToStringECMAScript(m_matrix.e()));
409         builder.appendLiteral(", ");
410         builder.append(String::numberToStringECMAScript(m_matrix.f()));
411     } else {
412         builder.appendLiteral("matrix3d(");
413         builder.append(String::numberToStringECMAScript(m_matrix.m11()));
414         builder.appendLiteral(", ");
415         builder.append(String::numberToStringECMAScript(m_matrix.m12()));
416         builder.appendLiteral(", ");
417         builder.append(String::numberToStringECMAScript(m_matrix.m13()));
418         builder.appendLiteral(", ");
419         builder.append(String::numberToStringECMAScript(m_matrix.m14()));
420         builder.appendLiteral(", ");
421         builder.append(String::numberToStringECMAScript(m_matrix.m21()));
422         builder.appendLiteral(", ");
423         builder.append(String::numberToStringECMAScript(m_matrix.m22()));
424         builder.appendLiteral(", ");
425         builder.append(String::numberToStringECMAScript(m_matrix.m23()));
426         builder.appendLiteral(", ");
427         builder.append(String::numberToStringECMAScript(m_matrix.m24()));
428         builder.appendLiteral(", ");
429         builder.append(String::numberToStringECMAScript(m_matrix.m31()));
430         builder.appendLiteral(", ");
431         builder.append(String::numberToStringECMAScript(m_matrix.m32()));
432         builder.appendLiteral(", ");
433         builder.append(String::numberToStringECMAScript(m_matrix.m33()));
434         builder.appendLiteral(", ");
435         builder.append(String::numberToStringECMAScript(m_matrix.m34()));
436         builder.appendLiteral(", ");
437         builder.append(String::numberToStringECMAScript(m_matrix.m41()));
438         builder.appendLiteral(", ");
439         builder.append(String::numberToStringECMAScript(m_matrix.m42()));
440         builder.appendLiteral(", ");
441         builder.append(String::numberToStringECMAScript(m_matrix.m43()));
442         builder.appendLiteral(", ");
443         builder.append(String::numberToStringECMAScript(m_matrix.m44()));
444     }
445     builder.append(')');
446     return builder.toString();
447 }
448
449 } // namespace WebCore