Replace some auto* with RefPtr within WebCore/html
[WebKit-https.git] / Source / WebCore / html / canvas / CanvasRenderingContext2D.cpp
1 /*
2  * Copyright (C) 2004-2017 Apple Inc. All rights reserved.
3  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
4  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
5  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
6  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
7  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
8  * Copyright (C) 2012 Intel Corporation. All rights reserved.
9  * Copyright (C) 2013, 2014 Adobe Systems Incorporated. All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
21  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
28  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #include "config.h"
34 #include "CanvasRenderingContext2D.h"
35
36 #include "BitmapImage.h"
37 #include "CSSFontSelector.h"
38 #include "CSSParser.h"
39 #include "CSSPropertyNames.h"
40 #include "CachedImage.h"
41 #include "CanvasGradient.h"
42 #include "CanvasPattern.h"
43 #include "DOMMatrix.h"
44 #include "DOMMatrix2DInit.h"
45 #include "DisplayListRecorder.h"
46 #include "DisplayListReplayer.h"
47 #include "FloatQuad.h"
48 #include "HTMLImageElement.h"
49 #include "HTMLVideoElement.h"
50 #include "ImageBitmap.h"
51 #include "ImageBuffer.h"
52 #include "ImageData.h"
53 #include "Path2D.h"
54 #include "RenderElement.h"
55 #include "RenderImage.h"
56 #include "RenderLayer.h"
57 #include "RenderTheme.h"
58 #include "SecurityOrigin.h"
59 #include "StrokeStyleApplier.h"
60 #include "StyleProperties.h"
61 #include "StyleResolver.h"
62 #include "TextMetrics.h"
63 #include "TextRun.h"
64 #include <wtf/CheckedArithmetic.h>
65 #include <wtf/MathExtras.h>
66 #include <wtf/NeverDestroyed.h>
67 #include <wtf/text/StringBuilder.h>
68 #include <wtf/text/TextStream.h>
69
70 #if USE(CG) && !PLATFORM(IOS)
71 #include <ApplicationServices/ApplicationServices.h>
72 #endif
73
74 namespace WebCore {
75
76 using namespace HTMLNames;
77
78 #if USE(CG)
79 const ImageSmoothingQuality defaultSmoothingQuality = ImageSmoothingQuality::Low;
80 #else
81 const ImageSmoothingQuality defaultSmoothingQuality = ImageSmoothingQuality::Medium;
82 #endif
83
84 static const int defaultFontSize = 10;
85 static const char* const defaultFontFamily = "sans-serif";
86 static const char* const defaultFont = "10px sans-serif";
87
88 struct DisplayListDrawingContext {
89     WTF_MAKE_FAST_ALLOCATED;
90 public:
91     GraphicsContext context;
92     DisplayList::Recorder recorder;
93     DisplayList::DisplayList displayList;
94     
95     DisplayListDrawingContext(const FloatRect& clip)
96         : recorder(context, displayList, clip, AffineTransform())
97     {
98     }
99 };
100
101 typedef HashMap<const CanvasRenderingContext2D*, std::unique_ptr<DisplayList::DisplayList>> ContextDisplayListHashMap;
102
103 static ContextDisplayListHashMap& contextDisplayListMap()
104 {
105     static NeverDestroyed<ContextDisplayListHashMap> sharedHashMap;
106     return sharedHashMap;
107 }
108
109 class CanvasStrokeStyleApplier : public StrokeStyleApplier {
110 public:
111     CanvasStrokeStyleApplier(CanvasRenderingContext2D* canvasContext)
112         : m_canvasContext(canvasContext)
113     {
114     }
115
116     void strokeStyle(GraphicsContext* c) override
117     {
118         c->setStrokeThickness(m_canvasContext->lineWidth());
119         c->setLineCap(m_canvasContext->getLineCap());
120         c->setLineJoin(m_canvasContext->getLineJoin());
121         c->setMiterLimit(m_canvasContext->miterLimit());
122         const Vector<float>& lineDash = m_canvasContext->getLineDash();
123         DashArray convertedLineDash(lineDash.size());
124         for (size_t i = 0; i < lineDash.size(); ++i)
125             convertedLineDash[i] = static_cast<DashArrayElement>(lineDash[i]);
126         c->setLineDash(convertedLineDash, m_canvasContext->lineDashOffset());
127     }
128
129 private:
130     CanvasRenderingContext2D* m_canvasContext;
131 };
132
133 CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement& canvas, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode)
134     : CanvasRenderingContext(canvas)
135     , m_stateStack(1)
136     , m_usesCSSCompatibilityParseMode(usesCSSCompatibilityParseMode)
137 #if ENABLE(DASHBOARD_SUPPORT)
138     , m_usesDashboardCompatibilityMode(usesDashboardCompatibilityMode)
139 #endif
140 {
141 #if !ENABLE(DASHBOARD_SUPPORT)
142     ASSERT_UNUSED(usesDashboardCompatibilityMode, !usesDashboardCompatibilityMode);
143 #endif
144 }
145
146 void CanvasRenderingContext2D::unwindStateStack()
147 {
148     // Ensure that the state stack in the ImageBuffer's context
149     // is cleared before destruction, to avoid assertions in the
150     // GraphicsContext dtor.
151     if (size_t stackSize = m_stateStack.size()) {
152         if (GraphicsContext* context = canvas().existingDrawingContext()) {
153             while (--stackSize)
154                 context->restore();
155         }
156     }
157 }
158
159 CanvasRenderingContext2D::~CanvasRenderingContext2D()
160 {
161 #if !ASSERT_DISABLED
162     unwindStateStack();
163 #endif
164
165     if (UNLIKELY(tracksDisplayListReplay()))
166         contextDisplayListMap().remove(this);
167 }
168
169 bool CanvasRenderingContext2D::isAccelerated() const
170 {
171 #if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
172     if (!canvas().hasCreatedImageBuffer())
173         return false;
174     auto* context = drawingContext();
175     return context && context->isAcceleratedContext();
176 #else
177     return false;
178 #endif
179 }
180
181 void CanvasRenderingContext2D::reset()
182 {
183     unwindStateStack();
184     m_stateStack.resize(1);
185     m_stateStack.first() = State();
186     m_path.clear();
187     m_unrealizedSaveCount = 0;
188     
189     m_recordingContext = nullptr;
190 }
191
192 CanvasRenderingContext2D::State::State()
193     : strokeStyle(Color::black)
194     , fillStyle(Color::black)
195     , lineWidth(1)
196     , lineCap(ButtCap)
197     , lineJoin(MiterJoin)
198     , miterLimit(10)
199     , shadowBlur(0)
200     , shadowColor(Color::transparent)
201     , globalAlpha(1)
202     , globalComposite(CompositeSourceOver)
203     , globalBlend(BlendModeNormal)
204     , hasInvertibleTransform(true)
205     , lineDashOffset(0)
206     , imageSmoothingEnabled(true)
207     , imageSmoothingQuality(defaultSmoothingQuality)
208     , textAlign(StartTextAlign)
209     , textBaseline(AlphabeticTextBaseline)
210     , direction(Direction::Inherit)
211     , unparsedFont(defaultFont)
212 {
213 }
214
215 CanvasRenderingContext2D::State::State(const State& other)
216     : unparsedStrokeColor(other.unparsedStrokeColor)
217     , unparsedFillColor(other.unparsedFillColor)
218     , strokeStyle(other.strokeStyle)
219     , fillStyle(other.fillStyle)
220     , lineWidth(other.lineWidth)
221     , lineCap(other.lineCap)
222     , lineJoin(other.lineJoin)
223     , miterLimit(other.miterLimit)
224     , shadowOffset(other.shadowOffset)
225     , shadowBlur(other.shadowBlur)
226     , shadowColor(other.shadowColor)
227     , globalAlpha(other.globalAlpha)
228     , globalComposite(other.globalComposite)
229     , globalBlend(other.globalBlend)
230     , transform(other.transform)
231     , hasInvertibleTransform(other.hasInvertibleTransform)
232     , lineDashOffset(other.lineDashOffset)
233     , imageSmoothingEnabled(other.imageSmoothingEnabled)
234     , imageSmoothingQuality(other.imageSmoothingQuality)
235     , textAlign(other.textAlign)
236     , textBaseline(other.textBaseline)
237     , direction(other.direction)
238     , unparsedFont(other.unparsedFont)
239     , font(other.font)
240 {
241 }
242
243 CanvasRenderingContext2D::State& CanvasRenderingContext2D::State::operator=(const State& other)
244 {
245     if (this == &other)
246         return *this;
247
248     unparsedStrokeColor = other.unparsedStrokeColor;
249     unparsedFillColor = other.unparsedFillColor;
250     strokeStyle = other.strokeStyle;
251     fillStyle = other.fillStyle;
252     lineWidth = other.lineWidth;
253     lineCap = other.lineCap;
254     lineJoin = other.lineJoin;
255     miterLimit = other.miterLimit;
256     shadowOffset = other.shadowOffset;
257     shadowBlur = other.shadowBlur;
258     shadowColor = other.shadowColor;
259     globalAlpha = other.globalAlpha;
260     globalComposite = other.globalComposite;
261     globalBlend = other.globalBlend;
262     transform = other.transform;
263     hasInvertibleTransform = other.hasInvertibleTransform;
264     imageSmoothingEnabled = other.imageSmoothingEnabled;
265     imageSmoothingQuality = other.imageSmoothingQuality;
266     textAlign = other.textAlign;
267     textBaseline = other.textBaseline;
268     direction = other.direction;
269     unparsedFont = other.unparsedFont;
270     font = other.font;
271
272     return *this;
273 }
274
275 CanvasRenderingContext2D::FontProxy::~FontProxy()
276 {
277     if (realized())
278         m_font.fontSelector()->unregisterForInvalidationCallbacks(*this);
279 }
280
281 CanvasRenderingContext2D::FontProxy::FontProxy(const FontProxy& other)
282     : m_font(other.m_font)
283 {
284     if (realized())
285         m_font.fontSelector()->registerForInvalidationCallbacks(*this);
286 }
287
288 auto CanvasRenderingContext2D::FontProxy::operator=(const FontProxy& other) -> FontProxy&
289 {
290     if (realized())
291         m_font.fontSelector()->unregisterForInvalidationCallbacks(*this);
292
293     m_font = other.m_font;
294
295     if (realized())
296         m_font.fontSelector()->registerForInvalidationCallbacks(*this);
297
298     return *this;
299 }
300
301 inline void CanvasRenderingContext2D::FontProxy::update(FontSelector& selector)
302 {
303     ASSERT(&selector == m_font.fontSelector()); // This is an invariant. We should only ever be registered for callbacks on m_font.m_fonts.m_fontSelector.
304     if (realized())
305         m_font.fontSelector()->unregisterForInvalidationCallbacks(*this);
306     m_font.update(&selector);
307     if (realized())
308         m_font.fontSelector()->registerForInvalidationCallbacks(*this);
309     ASSERT(&selector == m_font.fontSelector());
310 }
311
312 void CanvasRenderingContext2D::FontProxy::fontsNeedUpdate(FontSelector& selector)
313 {
314     ASSERT_ARG(selector, &selector == m_font.fontSelector());
315     ASSERT(realized());
316
317     update(selector);
318 }
319
320 inline void CanvasRenderingContext2D::FontProxy::initialize(FontSelector& fontSelector, const RenderStyle& newStyle)
321 {
322     // Beware! m_font.fontSelector() might not point to document.fontSelector()!
323     ASSERT(newStyle.fontCascade().fontSelector() == &fontSelector);
324     if (realized())
325         m_font.fontSelector()->unregisterForInvalidationCallbacks(*this);
326     m_font = newStyle.fontCascade();
327     m_font.update(&fontSelector);
328     ASSERT(&fontSelector == m_font.fontSelector());
329     m_font.fontSelector()->registerForInvalidationCallbacks(*this);
330 }
331
332 inline const FontMetrics& CanvasRenderingContext2D::FontProxy::fontMetrics() const
333 {
334     return m_font.fontMetrics();
335 }
336
337 inline const FontCascadeDescription& CanvasRenderingContext2D::FontProxy::fontDescription() const
338 {
339     return m_font.fontDescription();
340 }
341
342 inline float CanvasRenderingContext2D::FontProxy::width(const TextRun& textRun, GlyphOverflow* overflow) const
343 {
344     return m_font.width(textRun, 0, overflow);
345 }
346
347 inline void CanvasRenderingContext2D::FontProxy::drawBidiText(GraphicsContext& context, const TextRun& run, const FloatPoint& point, FontCascade::CustomFontNotReadyAction action) const
348 {
349     context.drawBidiText(m_font, run, point, action);
350 }
351
352 void CanvasRenderingContext2D::realizeSaves()
353 {
354     if (m_unrealizedSaveCount)
355         realizeSavesLoop();
356
357     if (m_unrealizedSaveCount) {
358         static NeverDestroyed<String> consoleMessage(MAKE_STATIC_STRING_IMPL("CanvasRenderingContext2D.save() has been called without a matching restore() too many times. Ignoring save()."));
359         canvas().document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, consoleMessage);
360     }
361 }
362
363 void CanvasRenderingContext2D::realizeSavesLoop()
364 {
365     ASSERT(m_unrealizedSaveCount);
366     ASSERT(m_stateStack.size() >= 1);
367     GraphicsContext* context = drawingContext();
368     do {
369         if (m_stateStack.size() > MaxSaveCount)
370             break;
371         m_stateStack.append(state());
372         if (context)
373             context->save();
374     } while (--m_unrealizedSaveCount);
375 }
376
377 void CanvasRenderingContext2D::restore()
378 {
379     if (m_unrealizedSaveCount) {
380         --m_unrealizedSaveCount;
381         return;
382     }
383     ASSERT(m_stateStack.size() >= 1);
384     if (m_stateStack.size() <= 1)
385         return;
386     m_path.transform(state().transform);
387     m_stateStack.removeLast();
388     if (std::optional<AffineTransform> inverse = state().transform.inverse())
389         m_path.transform(inverse.value());
390     GraphicsContext* c = drawingContext();
391     if (!c)
392         return;
393     c->restore();
394 }
395
396 void CanvasRenderingContext2D::setStrokeStyle(CanvasStyle style)
397 {
398     if (!style.isValid())
399         return;
400
401     if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentColor(style))
402         return;
403
404     if (style.isCurrentColor()) {
405         if (style.hasOverrideAlpha()) {
406             // FIXME: Should not use RGBA32 here.
407             style = CanvasStyle(colorWithOverrideAlpha(currentColor(&canvas()).rgb(), style.overrideAlpha()));
408         } else
409             style = CanvasStyle(currentColor(&canvas()));
410     } else
411         checkOrigin(style.canvasPattern().get());
412
413     realizeSaves();
414     State& state = modifiableState();
415     state.strokeStyle = style;
416     GraphicsContext* c = drawingContext();
417     if (!c)
418         return;
419     state.strokeStyle.applyStrokeColor(*c);
420     state.unparsedStrokeColor = String();
421 }
422
423 void CanvasRenderingContext2D::setFillStyle(CanvasStyle style)
424 {
425     if (!style.isValid())
426         return;
427
428     if (state().fillStyle.isValid() && state().fillStyle.isEquivalentColor(style))
429         return;
430
431     if (style.isCurrentColor()) {
432         if (style.hasOverrideAlpha()) {
433             // FIXME: Should not use RGBA32 here.
434             style = CanvasStyle(colorWithOverrideAlpha(currentColor(&canvas()).rgb(), style.overrideAlpha()));
435         } else
436             style = CanvasStyle(currentColor(&canvas()));
437     } else
438         checkOrigin(style.canvasPattern().get());
439
440     realizeSaves();
441     State& state = modifiableState();
442     state.fillStyle = style;
443     GraphicsContext* c = drawingContext();
444     if (!c)
445         return;
446     state.fillStyle.applyFillColor(*c);
447     state.unparsedFillColor = String();
448 }
449
450 float CanvasRenderingContext2D::lineWidth() const
451 {
452     return state().lineWidth;
453 }
454
455 void CanvasRenderingContext2D::setLineWidth(float width)
456 {
457     if (!(std::isfinite(width) && width > 0))
458         return;
459     if (state().lineWidth == width)
460         return;
461     realizeSaves();
462     modifiableState().lineWidth = width;
463     GraphicsContext* c = drawingContext();
464     if (!c)
465         return;
466     c->setStrokeThickness(width);
467 }
468
469 static CanvasLineCap toCanvasLineCap(LineCap lineCap)
470 {
471     switch (lineCap) {
472     case ButtCap:
473         return CanvasLineCap::Butt;
474     case RoundCap:
475         return CanvasLineCap::Round;
476     case SquareCap:
477         return CanvasLineCap::Square;
478     }
479
480     ASSERT_NOT_REACHED();
481     return CanvasLineCap::Butt;
482 }
483
484 static LineCap fromCanvasLineCap(CanvasLineCap canvasLineCap)
485 {
486     switch (canvasLineCap) {
487     case CanvasLineCap::Butt:
488         return ButtCap;
489     case CanvasLineCap::Round:
490         return RoundCap;
491     case CanvasLineCap::Square:
492         return SquareCap;
493     }
494     
495     ASSERT_NOT_REACHED();
496     return ButtCap;
497 }
498
499 CanvasLineCap CanvasRenderingContext2D::lineCap() const
500 {
501     return toCanvasLineCap(state().lineCap);
502 }
503
504 void CanvasRenderingContext2D::setLineCap(CanvasLineCap canvasLineCap)
505 {
506     auto lineCap = fromCanvasLineCap(canvasLineCap);
507     if (state().lineCap == lineCap)
508         return;
509     realizeSaves();
510     modifiableState().lineCap = lineCap;
511     GraphicsContext* c = drawingContext();
512     if (!c)
513         return;
514     c->setLineCap(lineCap);
515 }
516
517 void CanvasRenderingContext2D::setLineCap(const String& stringValue)
518 {
519     CanvasLineCap cap;
520     if (stringValue == "butt")
521         cap = CanvasLineCap::Butt;
522     else if (stringValue == "round")
523         cap = CanvasLineCap::Round;
524     else if (stringValue == "square")
525         cap = CanvasLineCap::Square;
526     else
527         return;
528     
529     setLineCap(cap);
530 }
531
532 static CanvasLineJoin toCanvasLineJoin(LineJoin lineJoin)
533 {
534     switch (lineJoin) {
535     case RoundJoin:
536         return CanvasLineJoin::Round;
537     case BevelJoin:
538         return CanvasLineJoin::Bevel;
539     case MiterJoin:
540         return CanvasLineJoin::Miter;
541     }
542
543     ASSERT_NOT_REACHED();
544     return CanvasLineJoin::Round;
545 }
546
547 static LineJoin fromCanvasLineJoin(CanvasLineJoin canvasLineJoin)
548 {
549     switch (canvasLineJoin) {
550     case CanvasLineJoin::Round:
551         return RoundJoin;
552     case CanvasLineJoin::Bevel:
553         return BevelJoin;
554     case CanvasLineJoin::Miter:
555         return MiterJoin;
556     }
557     
558     ASSERT_NOT_REACHED();
559     return RoundJoin;
560 }
561
562 CanvasLineJoin CanvasRenderingContext2D::lineJoin() const
563 {
564     return toCanvasLineJoin(state().lineJoin);
565 }
566
567 void CanvasRenderingContext2D::setLineJoin(CanvasLineJoin canvasLineJoin)
568 {
569     auto lineJoin = fromCanvasLineJoin(canvasLineJoin);
570     if (state().lineJoin == lineJoin)
571         return;
572     realizeSaves();
573     modifiableState().lineJoin = lineJoin;
574     GraphicsContext* c = drawingContext();
575     if (!c)
576         return;
577     c->setLineJoin(lineJoin);
578 }
579
580 void CanvasRenderingContext2D::setLineJoin(const String& stringValue)
581 {
582     CanvasLineJoin join;
583     if (stringValue == "round")
584         join = CanvasLineJoin::Round;
585     else if (stringValue == "bevel")
586         join = CanvasLineJoin::Bevel;
587     else if (stringValue == "miter")
588         join = CanvasLineJoin::Miter;
589     else
590         return;
591
592     setLineJoin(join);
593 }
594
595 float CanvasRenderingContext2D::miterLimit() const
596 {
597     return state().miterLimit;
598 }
599
600 void CanvasRenderingContext2D::setMiterLimit(float limit)
601 {
602     if (!(std::isfinite(limit) && limit > 0))
603         return;
604     if (state().miterLimit == limit)
605         return;
606     realizeSaves();
607     modifiableState().miterLimit = limit;
608     GraphicsContext* c = drawingContext();
609     if (!c)
610         return;
611     c->setMiterLimit(limit);
612 }
613
614 float CanvasRenderingContext2D::shadowOffsetX() const
615 {
616     return state().shadowOffset.width();
617 }
618
619 void CanvasRenderingContext2D::setShadowOffsetX(float x)
620 {
621     if (!std::isfinite(x))
622         return;
623     if (state().shadowOffset.width() == x)
624         return;
625     realizeSaves();
626     modifiableState().shadowOffset.setWidth(x);
627     applyShadow();
628 }
629
630 float CanvasRenderingContext2D::shadowOffsetY() const
631 {
632     return state().shadowOffset.height();
633 }
634
635 void CanvasRenderingContext2D::setShadowOffsetY(float y)
636 {
637     if (!std::isfinite(y))
638         return;
639     if (state().shadowOffset.height() == y)
640         return;
641     realizeSaves();
642     modifiableState().shadowOffset.setHeight(y);
643     applyShadow();
644 }
645
646 float CanvasRenderingContext2D::shadowBlur() const
647 {
648     return state().shadowBlur;
649 }
650
651 void CanvasRenderingContext2D::setShadowBlur(float blur)
652 {
653     if (!(std::isfinite(blur) && blur >= 0))
654         return;
655     if (state().shadowBlur == blur)
656         return;
657     realizeSaves();
658     modifiableState().shadowBlur = blur;
659     applyShadow();
660 }
661
662 String CanvasRenderingContext2D::shadowColor() const
663 {
664     return Color(state().shadowColor).serialized();
665 }
666
667 void CanvasRenderingContext2D::setShadowColor(const String& colorString)
668 {
669     Color color = parseColorOrCurrentColor(colorString, &canvas());
670     if (!color.isValid())
671         return;
672     if (state().shadowColor == color)
673         return;
674     realizeSaves();
675     modifiableState().shadowColor = color;
676     applyShadow();
677 }
678
679 const Vector<float>& CanvasRenderingContext2D::getLineDash() const
680 {
681     return state().lineDash;
682 }
683
684 static bool lineDashSequenceIsValid(const Vector<float>& dash)
685 {
686     for (size_t i = 0; i < dash.size(); i++) {
687         if (!std::isfinite(dash[i]) || dash[i] < 0)
688             return false;
689     }
690     return true;
691 }
692
693 void CanvasRenderingContext2D::setLineDash(const Vector<float>& dash)
694 {
695     if (!lineDashSequenceIsValid(dash))
696         return;
697
698     realizeSaves();
699     modifiableState().lineDash = dash;
700     // Spec requires the concatenation of two copies the dash list when the
701     // number of elements is odd
702     if (dash.size() % 2)
703         modifiableState().lineDash.appendVector(dash);
704
705     applyLineDash();
706 }
707
708 void CanvasRenderingContext2D::setWebkitLineDash(const Vector<float>& dash)
709 {
710     if (!lineDashSequenceIsValid(dash))
711         return;
712
713     realizeSaves();
714     modifiableState().lineDash = dash;
715
716     applyLineDash();
717 }
718
719 float CanvasRenderingContext2D::lineDashOffset() const
720 {
721     return state().lineDashOffset;
722 }
723
724 void CanvasRenderingContext2D::setLineDashOffset(float offset)
725 {
726     if (!std::isfinite(offset) || state().lineDashOffset == offset)
727         return;
728
729     realizeSaves();
730     modifiableState().lineDashOffset = offset;
731     applyLineDash();
732 }
733
734 void CanvasRenderingContext2D::applyLineDash() const
735 {
736     GraphicsContext* c = drawingContext();
737     if (!c)
738         return;
739     DashArray convertedLineDash(state().lineDash.size());
740     for (size_t i = 0; i < state().lineDash.size(); ++i)
741         convertedLineDash[i] = static_cast<DashArrayElement>(state().lineDash[i]);
742     c->setLineDash(convertedLineDash, state().lineDashOffset);
743 }
744
745 float CanvasRenderingContext2D::globalAlpha() const
746 {
747     return state().globalAlpha;
748 }
749
750 void CanvasRenderingContext2D::setGlobalAlpha(float alpha)
751 {
752     if (!(alpha >= 0 && alpha <= 1))
753         return;
754     if (state().globalAlpha == alpha)
755         return;
756     realizeSaves();
757     modifiableState().globalAlpha = alpha;
758     GraphicsContext* c = drawingContext();
759     if (!c)
760         return;
761     c->setAlpha(alpha);
762 }
763
764 String CanvasRenderingContext2D::globalCompositeOperation() const
765 {
766     return compositeOperatorName(state().globalComposite, state().globalBlend);
767 }
768
769 void CanvasRenderingContext2D::setGlobalCompositeOperation(const String& operation)
770 {
771     CompositeOperator op = CompositeSourceOver;
772     BlendMode blendMode = BlendModeNormal;
773     if (!parseCompositeAndBlendOperator(operation, op, blendMode))
774         return;
775     if ((state().globalComposite == op) && (state().globalBlend == blendMode))
776         return;
777     realizeSaves();
778     modifiableState().globalComposite = op;
779     modifiableState().globalBlend = blendMode;
780     GraphicsContext* c = drawingContext();
781     if (!c)
782         return;
783     c->setCompositeOperation(op, blendMode);
784 }
785
786 void CanvasRenderingContext2D::scale(float sx, float sy)
787 {
788     GraphicsContext* c = drawingContext();
789     if (!c)
790         return;
791     if (!state().hasInvertibleTransform)
792         return;
793
794     if (!std::isfinite(sx) || !std::isfinite(sy))
795         return;
796
797     AffineTransform newTransform = state().transform;
798     newTransform.scaleNonUniform(sx, sy);
799     if (state().transform == newTransform)
800         return;
801
802     realizeSaves();
803
804     if (!sx || !sy) {
805         modifiableState().hasInvertibleTransform = false;
806         return;
807     }
808
809     modifiableState().transform = newTransform;
810     c->scale(FloatSize(sx, sy));
811     m_path.transform(AffineTransform().scaleNonUniform(1.0 / sx, 1.0 / sy));
812 }
813
814 void CanvasRenderingContext2D::rotate(float angleInRadians)
815 {
816     GraphicsContext* c = drawingContext();
817     if (!c)
818         return;
819     if (!state().hasInvertibleTransform)
820         return;
821
822     if (!std::isfinite(angleInRadians))
823         return;
824
825     AffineTransform newTransform = state().transform;
826     newTransform.rotate(angleInRadians / piDouble * 180.0);
827     if (state().transform == newTransform)
828         return;
829
830     realizeSaves();
831
832     modifiableState().transform = newTransform;
833     c->rotate(angleInRadians);
834     m_path.transform(AffineTransform().rotate(-angleInRadians / piDouble * 180.0));
835 }
836
837 void CanvasRenderingContext2D::translate(float tx, float ty)
838 {
839     GraphicsContext* c = drawingContext();
840     if (!c)
841         return;
842     if (!state().hasInvertibleTransform)
843         return;
844
845     if (!std::isfinite(tx) | !std::isfinite(ty))
846         return;
847
848     AffineTransform newTransform = state().transform;
849     newTransform.translate(tx, ty);
850     if (state().transform == newTransform)
851         return;
852
853     realizeSaves();
854
855     modifiableState().transform = newTransform;
856     c->translate(tx, ty);
857     m_path.transform(AffineTransform().translate(-tx, -ty));
858 }
859
860 void CanvasRenderingContext2D::transform(float m11, float m12, float m21, float m22, float dx, float dy)
861 {
862     GraphicsContext* c = drawingContext();
863     if (!c)
864         return;
865     if (!state().hasInvertibleTransform)
866         return;
867
868     if (!std::isfinite(m11) | !std::isfinite(m21) | !std::isfinite(dx) | !std::isfinite(m12) | !std::isfinite(m22) | !std::isfinite(dy))
869         return;
870
871     AffineTransform transform(m11, m12, m21, m22, dx, dy);
872     AffineTransform newTransform = state().transform * transform;
873     if (state().transform == newTransform)
874         return;
875
876     realizeSaves();
877
878     if (auto inverse = transform.inverse()) {
879         modifiableState().transform = newTransform;
880         c->concatCTM(transform);
881         m_path.transform(inverse.value());
882         return;
883     }
884     modifiableState().hasInvertibleTransform = false;
885 }
886
887 Ref<DOMMatrix> CanvasRenderingContext2D::getTransform() const
888 {
889     return DOMMatrix::create(state().transform.toTransformationMatrix(), DOMMatrixReadOnly::Is2D::Yes);
890 }
891
892 void CanvasRenderingContext2D::setTransform(float m11, float m12, float m21, float m22, float dx, float dy)
893 {
894     GraphicsContext* c = drawingContext();
895     if (!c)
896         return;
897
898     if (!std::isfinite(m11) | !std::isfinite(m21) | !std::isfinite(dx) | !std::isfinite(m12) | !std::isfinite(m22) | !std::isfinite(dy))
899         return;
900
901     resetTransform();
902     transform(m11, m12, m21, m22, dx, dy);
903 }
904
905 ExceptionOr<void> CanvasRenderingContext2D::setTransform(DOMMatrix2DInit&& matrixInit)
906 {
907     auto checkValid = DOMMatrixReadOnly::validateAndFixup(matrixInit);
908     if (checkValid.hasException())
909         return checkValid.releaseException();
910
911     setTransform(matrixInit.a.value_or(1), matrixInit.b.value_or(0), matrixInit.c.value_or(0), matrixInit.d.value_or(1), matrixInit.e.value_or(0), matrixInit.f.value_or(0));
912     return { };
913 }
914
915 void CanvasRenderingContext2D::resetTransform()
916 {
917     GraphicsContext* c = drawingContext();
918     if (!c)
919         return;
920
921     AffineTransform ctm = state().transform;
922     bool hasInvertibleTransform = state().hasInvertibleTransform;
923
924     realizeSaves();
925
926     c->setCTM(canvas().baseTransform());
927     modifiableState().transform = AffineTransform();
928
929     if (hasInvertibleTransform)
930         m_path.transform(ctm);
931
932     modifiableState().hasInvertibleTransform = true;
933 }
934
935 void CanvasRenderingContext2D::setStrokeColor(const String& color, std::optional<float> alpha)
936 {
937     if (alpha) {
938         setStrokeStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha.value()));
939         return;
940     }
941
942     if (color == state().unparsedStrokeColor)
943         return;
944
945     realizeSaves();
946     setStrokeStyle(CanvasStyle::createFromString(color));
947     modifiableState().unparsedStrokeColor = color;
948 }
949
950 void CanvasRenderingContext2D::setStrokeColor(float grayLevel, float alpha)
951 {
952     if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))
953         return;
954     setStrokeStyle(CanvasStyle(grayLevel, alpha));
955 }
956
957 void CanvasRenderingContext2D::setStrokeColor(float r, float g, float b, float a)
958 {
959     if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentRGBA(r, g, b, a))
960         return;
961     setStrokeStyle(CanvasStyle(r, g, b, a));
962 }
963
964 void CanvasRenderingContext2D::setStrokeColor(float c, float m, float y, float k, float a)
965 {
966     if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentCMYKA(c, m, y, k, a))
967         return;
968     setStrokeStyle(CanvasStyle(c, m, y, k, a));
969 }
970
971 void CanvasRenderingContext2D::setFillColor(const String& color, std::optional<float> alpha)
972 {
973     if (alpha) {
974         setFillStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha.value()));
975         return;
976     }
977
978     if (color == state().unparsedFillColor)
979         return;
980
981     realizeSaves();
982     setFillStyle(CanvasStyle::createFromString(color));
983     modifiableState().unparsedFillColor = color;
984 }
985
986 void CanvasRenderingContext2D::setFillColor(float grayLevel, float alpha)
987 {
988     if (state().fillStyle.isValid() && state().fillStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))
989         return;
990     setFillStyle(CanvasStyle(grayLevel, alpha));
991 }
992
993 void CanvasRenderingContext2D::setFillColor(float r, float g, float b, float a)
994 {
995     if (state().fillStyle.isValid() && state().fillStyle.isEquivalentRGBA(r, g, b, a))
996         return;
997     setFillStyle(CanvasStyle(r, g, b, a));
998 }
999
1000 void CanvasRenderingContext2D::setFillColor(float c, float m, float y, float k, float a)
1001 {
1002     if (state().fillStyle.isValid() && state().fillStyle.isEquivalentCMYKA(c, m, y, k, a))
1003         return;
1004     setFillStyle(CanvasStyle(c, m, y, k, a));
1005 }
1006
1007 void CanvasRenderingContext2D::beginPath()
1008 {
1009     m_path.clear();
1010 }
1011
1012 static bool validateRectForCanvas(float& x, float& y, float& width, float& height)
1013 {
1014     if (!std::isfinite(x) | !std::isfinite(y) | !std::isfinite(width) | !std::isfinite(height))
1015         return false;
1016
1017     if (!width && !height)
1018         return false;
1019
1020     if (width < 0) {
1021         width = -width;
1022         x -= width;
1023     }
1024
1025     if (height < 0) {
1026         height = -height;
1027         y -= height;
1028     }
1029
1030     return true;
1031 }
1032
1033 inline void CanvasRenderingContext2D::clearPathForDashboardBackwardCompatibilityMode()
1034 {
1035 #if ENABLE(DASHBOARD_SUPPORT)
1036     if (m_usesDashboardCompatibilityMode)
1037         m_path.clear();
1038 #endif
1039 }
1040
1041 static bool isFullCanvasCompositeMode(CompositeOperator op)
1042 {
1043     // See 4.8.11.1.3 Compositing
1044     // CompositeSourceAtop and CompositeDestinationOut are not listed here as the platforms already
1045     // implement the specification's behavior.
1046     return op == CompositeSourceIn || op == CompositeSourceOut || op == CompositeDestinationIn || op == CompositeDestinationAtop;
1047 }
1048
1049 static WindRule toWindRule(CanvasFillRule rule)
1050 {
1051     return rule == CanvasFillRule::Nonzero ? RULE_NONZERO : RULE_EVENODD;
1052 }
1053
1054 void CanvasRenderingContext2D::fill(CanvasFillRule windingRule)
1055 {
1056     fillInternal(m_path, windingRule);
1057     clearPathForDashboardBackwardCompatibilityMode();
1058 }
1059
1060 void CanvasRenderingContext2D::stroke()
1061 {
1062     strokeInternal(m_path);
1063     clearPathForDashboardBackwardCompatibilityMode();
1064 }
1065
1066 void CanvasRenderingContext2D::clip(CanvasFillRule windingRule)
1067 {
1068     clipInternal(m_path, windingRule);
1069     clearPathForDashboardBackwardCompatibilityMode();
1070 }
1071
1072 void CanvasRenderingContext2D::fill(Path2D& path, CanvasFillRule windingRule)
1073 {
1074     fillInternal(path.path(), windingRule);
1075 }
1076
1077 void CanvasRenderingContext2D::stroke(Path2D& path)
1078 {
1079     strokeInternal(path.path());
1080 }
1081
1082 void CanvasRenderingContext2D::clip(Path2D& path, CanvasFillRule windingRule)
1083 {
1084     clipInternal(path.path(), windingRule);
1085 }
1086
1087 void CanvasRenderingContext2D::fillInternal(const Path& path, CanvasFillRule windingRule)
1088 {
1089     auto* c = drawingContext();
1090     if (!c)
1091         return;
1092     if (!state().hasInvertibleTransform)
1093         return;
1094
1095     // If gradient size is zero, then paint nothing.
1096     auto gradient = c->fillGradient();
1097     if (gradient && gradient->isZeroSize())
1098         return;
1099
1100     if (!path.isEmpty()) {
1101         auto savedFillRule = c->fillRule();
1102         c->setFillRule(toWindRule(windingRule));
1103
1104         if (isFullCanvasCompositeMode(state().globalComposite)) {
1105             beginCompositeLayer();
1106             c->fillPath(path);
1107             endCompositeLayer();
1108             didDrawEntireCanvas();
1109         } else if (state().globalComposite == CompositeCopy) {
1110             clearCanvas();
1111             c->fillPath(path);
1112             didDrawEntireCanvas();
1113         } else {
1114             c->fillPath(path);
1115             didDraw(path.fastBoundingRect());
1116         }
1117         
1118         c->setFillRule(savedFillRule);
1119     }
1120 }
1121
1122 void CanvasRenderingContext2D::strokeInternal(const Path& path)
1123 {
1124     auto* c = drawingContext();
1125     if (!c)
1126         return;
1127     if (!state().hasInvertibleTransform)
1128         return;
1129
1130     // If gradient size is zero, then paint nothing.
1131     auto gradient = c->strokeGradient();
1132     if (gradient && gradient->isZeroSize())
1133         return;
1134
1135     if (!path.isEmpty()) {
1136         if (isFullCanvasCompositeMode(state().globalComposite)) {
1137             beginCompositeLayer();
1138             c->strokePath(path);
1139             endCompositeLayer();
1140             didDrawEntireCanvas();
1141         } else if (state().globalComposite == CompositeCopy) {
1142             clearCanvas();
1143             c->strokePath(path);
1144             didDrawEntireCanvas();
1145         } else {
1146             FloatRect dirtyRect = path.fastBoundingRect();
1147             inflateStrokeRect(dirtyRect);
1148             c->strokePath(path);
1149             didDraw(dirtyRect);
1150         }
1151     }
1152 }
1153
1154 void CanvasRenderingContext2D::clipInternal(const Path& path, CanvasFillRule windingRule)
1155 {
1156     auto* c = drawingContext();
1157     if (!c)
1158         return;
1159     if (!state().hasInvertibleTransform)
1160         return;
1161
1162     realizeSaves();
1163     c->canvasClip(path, toWindRule(windingRule));
1164 }
1165
1166 inline void CanvasRenderingContext2D::beginCompositeLayer()
1167 {
1168 #if !USE(CAIRO)
1169     drawingContext()->beginTransparencyLayer(1);
1170 #endif
1171 }
1172
1173 inline void CanvasRenderingContext2D::endCompositeLayer()
1174 {
1175 #if !USE(CAIRO)
1176     drawingContext()->endTransparencyLayer();    
1177 #endif
1178 }
1179
1180 bool CanvasRenderingContext2D::isPointInPath(float x, float y, CanvasFillRule windingRule)
1181 {
1182     return isPointInPathInternal(m_path, x, y, windingRule);
1183 }
1184
1185 bool CanvasRenderingContext2D::isPointInStroke(float x, float y)
1186 {
1187     return isPointInStrokeInternal(m_path, x, y);
1188 }
1189
1190 bool CanvasRenderingContext2D::isPointInPath(Path2D& path, float x, float y, CanvasFillRule windingRule)
1191 {
1192     return isPointInPathInternal(path.path(), x, y, windingRule);
1193 }
1194
1195 bool CanvasRenderingContext2D::isPointInStroke(Path2D& path, float x, float y)
1196 {
1197     return isPointInStrokeInternal(path.path(), x, y);
1198 }
1199
1200 bool CanvasRenderingContext2D::isPointInPathInternal(const Path& path, float x, float y, CanvasFillRule windingRule)
1201 {
1202     auto* c = drawingContext();
1203     if (!c)
1204         return false;
1205     if (!state().hasInvertibleTransform)
1206         return false;
1207
1208     auto transformedPoint = state().transform.inverse().value_or(AffineTransform()).mapPoint(FloatPoint(x, y));
1209
1210     if (!std::isfinite(transformedPoint.x()) || !std::isfinite(transformedPoint.y()))
1211         return false;
1212
1213     return path.contains(transformedPoint, toWindRule(windingRule));
1214 }
1215
1216 bool CanvasRenderingContext2D::isPointInStrokeInternal(const Path& path, float x, float y)
1217 {
1218     auto* c = drawingContext();
1219     if (!c)
1220         return false;
1221     if (!state().hasInvertibleTransform)
1222         return false;
1223
1224     auto transformedPoint = state().transform.inverse().value_or(AffineTransform()).mapPoint(FloatPoint(x, y));
1225     if (!std::isfinite(transformedPoint.x()) || !std::isfinite(transformedPoint.y()))
1226         return false;
1227
1228     CanvasStrokeStyleApplier applier(this);
1229     return path.strokeContains(&applier, transformedPoint);
1230 }
1231
1232 void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height)
1233 {
1234     if (!validateRectForCanvas(x, y, width, height))
1235         return;
1236     auto* context = drawingContext();
1237     if (!context)
1238         return;
1239     if (!state().hasInvertibleTransform)
1240         return;
1241     FloatRect rect(x, y, width, height);
1242
1243     bool saved = false;
1244     if (shouldDrawShadows()) {
1245         context->save();
1246         saved = true;
1247         context->setLegacyShadow(FloatSize(), 0, Color::transparent);
1248     }
1249     if (state().globalAlpha != 1) {
1250         if (!saved) {
1251             context->save();
1252             saved = true;
1253         }
1254         context->setAlpha(1);
1255     }
1256     if (state().globalComposite != CompositeSourceOver) {
1257         if (!saved) {
1258             context->save();
1259             saved = true;
1260         }
1261         context->setCompositeOperation(CompositeSourceOver);
1262     }
1263     context->clearRect(rect);
1264     if (saved)
1265         context->restore();
1266     didDraw(rect);
1267 }
1268
1269 void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height)
1270 {
1271     if (!validateRectForCanvas(x, y, width, height))
1272         return;
1273
1274     auto* c = drawingContext();
1275     if (!c)
1276         return;
1277     if (!state().hasInvertibleTransform)
1278         return;
1279
1280     // from the HTML5 Canvas spec:
1281     // If x0 = x1 and y0 = y1, then the linear gradient must paint nothing
1282     // If x0 = x1 and y0 = y1 and r0 = r1, then the radial gradient must paint nothing
1283     auto gradient = c->fillGradient();
1284     if (gradient && gradient->isZeroSize())
1285         return;
1286
1287     FloatRect rect(x, y, width, height);
1288
1289     if (rectContainsCanvas(rect)) {
1290         c->fillRect(rect);
1291         didDrawEntireCanvas();
1292     } else if (isFullCanvasCompositeMode(state().globalComposite)) {
1293         beginCompositeLayer();
1294         c->fillRect(rect);
1295         endCompositeLayer();
1296         didDrawEntireCanvas();
1297     } else if (state().globalComposite == CompositeCopy) {
1298         clearCanvas();
1299         c->fillRect(rect);
1300         didDrawEntireCanvas();
1301     } else {
1302         c->fillRect(rect);
1303         didDraw(rect);
1304     }
1305 }
1306
1307 void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height)
1308 {
1309     if (!validateRectForCanvas(x, y, width, height))
1310         return;
1311
1312     auto* c = drawingContext();
1313     if (!c)
1314         return;
1315     if (!state().hasInvertibleTransform)
1316         return;
1317     if (!(state().lineWidth >= 0))
1318         return;
1319
1320     // If gradient size is zero, then paint nothing.
1321     auto gradient = c->strokeGradient();
1322     if (gradient && gradient->isZeroSize())
1323         return;
1324
1325     FloatRect rect(x, y, width, height);
1326     if (isFullCanvasCompositeMode(state().globalComposite)) {
1327         beginCompositeLayer();
1328         c->strokeRect(rect, state().lineWidth);
1329         endCompositeLayer();
1330         didDrawEntireCanvas();
1331     } else if (state().globalComposite == CompositeCopy) {
1332         clearCanvas();
1333         c->strokeRect(rect, state().lineWidth);
1334         didDrawEntireCanvas();
1335     } else {
1336         FloatRect boundingRect = rect;
1337         boundingRect.inflate(state().lineWidth / 2);
1338         c->strokeRect(rect, state().lineWidth);
1339         didDraw(boundingRect);
1340     }
1341 }
1342
1343 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& colorString, std::optional<float> alpha)
1344 {
1345     Color color = Color::transparent;
1346     if (!colorString.isNull()) {
1347         color = parseColorOrCurrentColor(colorString, &canvas());
1348         if (!color.isValid())
1349             return;
1350     }
1351     // FIXME: Should not use RGBA32 here.
1352     setShadow(FloatSize(width, height), blur, colorWithOverrideAlpha(color.rgb(), alpha));
1353 }
1354
1355 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel, float alpha)
1356 {
1357     setShadow(FloatSize(width, height), blur, Color(grayLevel, grayLevel, grayLevel, alpha));
1358 }
1359
1360 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float r, float g, float b, float a)
1361 {
1362     setShadow(FloatSize(width, height), blur, Color(r, g, b, a));
1363 }
1364
1365 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float c, float m, float y, float k, float a)
1366 {
1367     setShadow(FloatSize(width, height), blur, Color(c, m, y, k, a));
1368 }
1369
1370 void CanvasRenderingContext2D::clearShadow()
1371 {
1372     setShadow(FloatSize(), 0, Color::transparent);
1373 }
1374
1375 void CanvasRenderingContext2D::setShadow(const FloatSize& offset, float blur, const Color& color)
1376 {
1377     if (state().shadowOffset == offset && state().shadowBlur == blur && state().shadowColor == color)
1378         return;
1379     bool wasDrawingShadows = shouldDrawShadows();
1380     realizeSaves();
1381     modifiableState().shadowOffset = offset;
1382     modifiableState().shadowBlur = blur;
1383     modifiableState().shadowColor = color;
1384     if (!wasDrawingShadows && !shouldDrawShadows())
1385         return;
1386     applyShadow();
1387 }
1388
1389 void CanvasRenderingContext2D::applyShadow()
1390 {
1391     auto* c = drawingContext();
1392     if (!c)
1393         return;
1394
1395     if (shouldDrawShadows()) {
1396         float width = state().shadowOffset.width();
1397         float height = state().shadowOffset.height();
1398         c->setLegacyShadow(FloatSize(width, -height), state().shadowBlur, state().shadowColor);
1399     } else
1400         c->setLegacyShadow(FloatSize(), 0, Color::transparent);
1401 }
1402
1403 bool CanvasRenderingContext2D::shouldDrawShadows() const
1404 {
1405     return state().shadowColor.isVisible() && (state().shadowBlur || !state().shadowOffset.isZero());
1406 }
1407
1408 enum class ImageSizeType { AfterDevicePixelRatio, BeforeDevicePixelRatio };
1409 static LayoutSize size(HTMLImageElement& element, ImageSizeType sizeType = ImageSizeType::BeforeDevicePixelRatio)
1410 {
1411     LayoutSize size;
1412     if (auto* cachedImage = element.cachedImage()) {
1413         size = cachedImage->imageSizeForRenderer(element.renderer(), 1.0f); // FIXME: Not sure about this.
1414         if (sizeType == ImageSizeType::AfterDevicePixelRatio && is<RenderImage>(element.renderer()) && cachedImage->image() && !cachedImage->image()->hasRelativeWidth())
1415             size.scale(downcast<RenderImage>(*element.renderer()).imageDevicePixelRatio());
1416     }
1417     return size;
1418 }
1419
1420 static inline FloatSize size(HTMLCanvasElement& canvasElement)
1421 {
1422     return canvasElement.size();
1423 }
1424
1425 static inline FloatSize size(ImageBitmap& imageBitmap)
1426 {
1427     return FloatSize { static_cast<float>(imageBitmap.width()), static_cast<float>(imageBitmap.height()) };
1428 }
1429
1430 #if ENABLE(VIDEO)
1431
1432 static inline FloatSize size(HTMLVideoElement& video)
1433 {
1434     auto player = video.player();
1435     if (!player)
1436         return { };
1437     return player->naturalSize();
1438 }
1439
1440 #endif
1441
1442 static inline FloatRect normalizeRect(const FloatRect& rect)
1443 {
1444     return FloatRect(std::min(rect.x(), rect.maxX()),
1445         std::min(rect.y(), rect.maxY()),
1446         std::max(rect.width(), -rect.width()),
1447         std::max(rect.height(), -rect.height()));
1448 }
1449
1450 ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image, float dx, float dy)
1451 {
1452     return WTF::switchOn(image,
1453         [&] (RefPtr<HTMLImageElement>& imageElement) -> ExceptionOr<void> {
1454             LayoutSize destRectSize = size(*imageElement, ImageSizeType::AfterDevicePixelRatio);
1455             LayoutSize sourceRectSize = size(*imageElement, ImageSizeType::BeforeDevicePixelRatio);
1456             return this->drawImage(*imageElement, FloatRect { 0, 0, sourceRectSize.width(), sourceRectSize.height() }, FloatRect { dx, dy, destRectSize.width(), destRectSize.height() });
1457         },
1458         [&] (auto& element) -> ExceptionOr<void> {
1459             FloatSize elementSize = size(*element);
1460             return this->drawImage(*element, FloatRect { 0, 0, elementSize.width(), elementSize.height() }, FloatRect { dx, dy, elementSize.width(), elementSize.height() });
1461         }
1462     );
1463 }
1464
1465 ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image, float dx, float dy, float dw, float dh)
1466 {
1467     return WTF::switchOn(image,
1468         [&] (auto& element) -> ExceptionOr<void> {
1469             FloatSize elementSize = size(*element);
1470             return this->drawImage(*element, FloatRect { 0, 0, elementSize.width(), elementSize.height() }, FloatRect { dx, dy, dw, dh });
1471         }
1472     );
1473 }
1474
1475 ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh)
1476 {
1477     return WTF::switchOn(image,
1478         [&] (auto& element) -> ExceptionOr<void> {
1479             return this->drawImage(*element, FloatRect { sx, sy, sw, sh }, FloatRect { dx, dy, dw, dh });
1480         }
1481     );
1482 }
1483
1484 ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, const FloatRect& srcRect, const FloatRect& dstRect)
1485 {
1486     return drawImage(imageElement, srcRect, dstRect, state().globalComposite, state().globalBlend);
1487 }
1488
1489 ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator& op, const BlendMode& blendMode)
1490 {
1491     if (!std::isfinite(dstRect.x()) || !std::isfinite(dstRect.y()) || !std::isfinite(dstRect.width()) || !std::isfinite(dstRect.height())
1492         || !std::isfinite(srcRect.x()) || !std::isfinite(srcRect.y()) || !std::isfinite(srcRect.width()) || !std::isfinite(srcRect.height()))
1493         return { };
1494
1495     if (!dstRect.width() || !dstRect.height())
1496         return { };
1497
1498     if (!imageElement.complete())
1499         return { };
1500
1501     FloatRect normalizedSrcRect = normalizeRect(srcRect);
1502     FloatRect normalizedDstRect = normalizeRect(dstRect);
1503
1504     FloatRect imageRect = FloatRect(FloatPoint(), size(imageElement, ImageSizeType::BeforeDevicePixelRatio));
1505     if (!srcRect.width() || !srcRect.height())
1506         return Exception { IndexSizeError };
1507
1508     // When the source rectangle is outside the source image, the source rectangle must be clipped
1509     // to the source image and the destination rectangle must be clipped in the same proportion.
1510     FloatRect originalNormalizedSrcRect = normalizedSrcRect;
1511     normalizedSrcRect.intersect(imageRect);
1512     if (normalizedSrcRect.isEmpty())
1513         return { };
1514
1515     if (normalizedSrcRect != originalNormalizedSrcRect) {
1516         normalizedDstRect.setWidth(normalizedDstRect.width() * normalizedSrcRect.width() / originalNormalizedSrcRect.width());
1517         normalizedDstRect.setHeight(normalizedDstRect.height() * normalizedSrcRect.height() / originalNormalizedSrcRect.height());
1518         if (normalizedDstRect.isEmpty())
1519             return { };
1520     }
1521
1522     GraphicsContext* c = drawingContext();
1523     if (!c)
1524         return { };
1525     if (!state().hasInvertibleTransform)
1526         return { };
1527
1528     CachedImage* cachedImage = imageElement.cachedImage();
1529     if (!cachedImage)
1530         return { };
1531
1532     RefPtr<Image> image = cachedImage->imageForRenderer(imageElement.renderer());
1533     if (!image)
1534         return { };
1535
1536     ImageObserver* observer = image->imageObserver();
1537
1538     if (image->isSVGImage()) {
1539         image->setImageObserver(nullptr);
1540         image->setContainerSize(imageRect.size());
1541     }
1542
1543     if (image->isBitmapImage())
1544         downcast<BitmapImage>(*image).updateFromSettings(imageElement.document().settings());
1545
1546     if (rectContainsCanvas(normalizedDstRect)) {
1547         c->drawImage(*image, normalizedDstRect, normalizedSrcRect, ImagePaintingOptions(op, blendMode));
1548         didDrawEntireCanvas();
1549     } else if (isFullCanvasCompositeMode(op)) {
1550         fullCanvasCompositedDrawImage(*image, normalizedDstRect, normalizedSrcRect, op);
1551         didDrawEntireCanvas();
1552     } else if (op == CompositeCopy) {
1553         clearCanvas();
1554         c->drawImage(*image, normalizedDstRect, normalizedSrcRect, ImagePaintingOptions(op, blendMode));
1555         didDrawEntireCanvas();
1556     } else {
1557         c->drawImage(*image, normalizedDstRect, normalizedSrcRect, ImagePaintingOptions(op, blendMode));
1558         didDraw(normalizedDstRect);
1559     }
1560     
1561     if (image->isSVGImage())
1562         image->setImageObserver(observer);
1563
1564     checkOrigin(&imageElement);
1565
1566     return { };
1567 }
1568
1569 ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas, const FloatRect& srcRect, const FloatRect& dstRect)
1570 {
1571     FloatRect srcCanvasRect = FloatRect(FloatPoint(), sourceCanvas.size());
1572
1573     if (!srcCanvasRect.width() || !srcCanvasRect.height())
1574         return Exception { InvalidStateError };
1575
1576     if (!srcRect.width() || !srcRect.height())
1577         return Exception { IndexSizeError };
1578
1579     if (!srcCanvasRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height())
1580         return { };
1581
1582     GraphicsContext* c = drawingContext();
1583     if (!c)
1584         return { };
1585     if (!state().hasInvertibleTransform)
1586         return { };
1587
1588     // FIXME: Do this through platform-independent GraphicsContext API.
1589     ImageBuffer* buffer = sourceCanvas.buffer();
1590     if (!buffer)
1591         return { };
1592
1593     checkOrigin(&sourceCanvas);
1594
1595 #if ENABLE(ACCELERATED_2D_CANVAS)
1596     // If we're drawing from one accelerated canvas 2d to another, avoid calling sourceCanvas.makeRenderingResultsAvailable()
1597     // as that will do a readback to software.
1598     RefPtr<CanvasRenderingContext> sourceContext = sourceCanvas.renderingContext();
1599     // FIXME: Implement an accelerated path for drawing from a WebGL canvas to a 2d canvas when possible.
1600     if (!isAccelerated() || !sourceContext || !sourceContext->isAccelerated() || !sourceContext->is2d())
1601         sourceCanvas.makeRenderingResultsAvailable();
1602 #else
1603     sourceCanvas.makeRenderingResultsAvailable();
1604 #endif
1605
1606     if (rectContainsCanvas(dstRect)) {
1607         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
1608         didDrawEntireCanvas();
1609     } else if (isFullCanvasCompositeMode(state().globalComposite)) {
1610         fullCanvasCompositedDrawImage(*buffer, dstRect, srcRect, state().globalComposite);
1611         didDrawEntireCanvas();
1612     } else if (state().globalComposite == CompositeCopy) {
1613         clearCanvas();
1614         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
1615         didDrawEntireCanvas();
1616     } else {
1617         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
1618         didDraw(dstRect);
1619     }
1620
1621     return { };
1622 }
1623
1624 #if ENABLE(VIDEO)
1625
1626 ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, const FloatRect& srcRect, const FloatRect& dstRect)
1627 {
1628     if (video.readyState() == HTMLMediaElement::HAVE_NOTHING || video.readyState() == HTMLMediaElement::HAVE_METADATA)
1629         return { };
1630
1631     FloatRect videoRect = FloatRect(FloatPoint(), size(video));
1632     if (!srcRect.width() || !srcRect.height())
1633         return Exception { IndexSizeError };
1634
1635     if (!videoRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height())
1636         return { };
1637
1638     GraphicsContext* c = drawingContext();
1639     if (!c)
1640         return { };
1641     if (!state().hasInvertibleTransform)
1642         return { };
1643
1644     checkOrigin(&video);
1645
1646 #if USE(CG) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(GSTREAMER_GL) && USE(CAIRO))
1647     if (NativeImagePtr image = video.nativeImageForCurrentTime()) {
1648         c->drawNativeImage(image, FloatSize(video.videoWidth(), video.videoHeight()), dstRect, srcRect);
1649         if (rectContainsCanvas(dstRect))
1650             didDrawEntireCanvas();
1651         else
1652             didDraw(dstRect);
1653
1654         return { };
1655     }
1656 #endif
1657
1658     GraphicsContextStateSaver stateSaver(*c);
1659     c->clip(dstRect);
1660     c->translate(dstRect.location());
1661     c->scale(FloatSize(dstRect.width() / srcRect.width(), dstRect.height() / srcRect.height()));
1662     c->translate(-srcRect.location());
1663     video.paintCurrentFrameInContext(*c, FloatRect(FloatPoint(), size(video)));
1664     stateSaver.restore();
1665     didDraw(dstRect);
1666
1667     return { };
1668 }
1669
1670 #endif
1671
1672 ExceptionOr<void> CanvasRenderingContext2D::drawImage(ImageBitmap& imageBitmap, const FloatRect& srcRect, const FloatRect& dstRect)
1673 {
1674     if (!imageBitmap.width() || !imageBitmap.height())
1675         return Exception { InvalidStateError };
1676
1677     if (!srcRect.width() || !srcRect.height())
1678         return Exception { IndexSizeError };
1679
1680     FloatRect srcBitmapRect = FloatRect(FloatPoint(), FloatSize(imageBitmap.width(), imageBitmap.height()));
1681
1682     if (!srcBitmapRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height())
1683         return { };
1684
1685     GraphicsContext* c = drawingContext();
1686     if (!c)
1687         return { };
1688     if (!state().hasInvertibleTransform)
1689         return { };
1690
1691     ImageBuffer* buffer = imageBitmap.buffer();
1692     if (!buffer)
1693         return { };
1694
1695     checkOrigin(&imageBitmap);
1696
1697     if (rectContainsCanvas(dstRect)) {
1698         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
1699         didDrawEntireCanvas();
1700     } else if (isFullCanvasCompositeMode(state().globalComposite)) {
1701         fullCanvasCompositedDrawImage(*buffer, dstRect, srcRect, state().globalComposite);
1702         didDrawEntireCanvas();
1703     } else if (state().globalComposite == CompositeCopy) {
1704         clearCanvas();
1705         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
1706         didDrawEntireCanvas();
1707     } else {
1708         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
1709         didDraw(dstRect);
1710     }
1711
1712     return { };
1713 }
1714
1715 void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement& imageElement, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, const String& compositeOperation)
1716 {
1717     CompositeOperator op;
1718     auto blendOp = BlendModeNormal;
1719     if (!parseCompositeAndBlendOperator(compositeOperation, op, blendOp) || blendOp != BlendModeNormal)
1720         op = CompositeSourceOver;
1721     drawImage(imageElement, FloatRect { sx, sy, sw, sh }, FloatRect { dx, dy, dw, dh }, op, BlendModeNormal);
1722 }
1723
1724 void CanvasRenderingContext2D::clearCanvas()
1725 {
1726     auto* c = drawingContext();
1727     if (!c)
1728         return;
1729
1730     c->save();
1731     c->setCTM(canvas().baseTransform());
1732     c->clearRect(FloatRect(0, 0, canvas().width(), canvas().height()));
1733     c->restore();
1734 }
1735
1736 Path CanvasRenderingContext2D::transformAreaToDevice(const Path& path) const
1737 {
1738     Path transformed(path);
1739     transformed.transform(state().transform);
1740     transformed.transform(canvas().baseTransform());
1741     return transformed;
1742 }
1743
1744 Path CanvasRenderingContext2D::transformAreaToDevice(const FloatRect& rect) const
1745 {
1746     Path path;
1747     path.addRect(rect);
1748     return transformAreaToDevice(path);
1749 }
1750
1751 bool CanvasRenderingContext2D::rectContainsCanvas(const FloatRect& rect) const
1752 {
1753     FloatQuad quad(rect);
1754     FloatQuad canvasQuad(FloatRect(0, 0, canvas().width(), canvas().height()));
1755     return state().transform.mapQuad(quad).containsQuad(canvasQuad);
1756 }
1757
1758 template<class T> IntRect CanvasRenderingContext2D::calculateCompositingBufferRect(const T& area, IntSize* croppedOffset)
1759 {
1760     IntRect canvasRect(0, 0, canvas().width(), canvas().height());
1761     canvasRect = canvas().baseTransform().mapRect(canvasRect);
1762     Path path = transformAreaToDevice(area);
1763     IntRect bufferRect = enclosingIntRect(path.fastBoundingRect());
1764     IntPoint originalLocation = bufferRect.location();
1765     bufferRect.intersect(canvasRect);
1766     if (croppedOffset)
1767         *croppedOffset = originalLocation - bufferRect.location();
1768     return bufferRect;
1769 }
1770
1771 std::unique_ptr<ImageBuffer> CanvasRenderingContext2D::createCompositingBuffer(const IntRect& bufferRect)
1772 {
1773     return ImageBuffer::create(bufferRect.size(), isAccelerated() ? Accelerated : Unaccelerated);
1774 }
1775
1776 void CanvasRenderingContext2D::compositeBuffer(ImageBuffer& buffer, const IntRect& bufferRect, CompositeOperator op)
1777 {
1778     IntRect canvasRect(0, 0, canvas().width(), canvas().height());
1779     canvasRect = canvas().baseTransform().mapRect(canvasRect);
1780
1781     auto* c = drawingContext();
1782     if (!c)
1783         return;
1784
1785     c->save();
1786     c->setCTM(AffineTransform());
1787     c->setCompositeOperation(op);
1788
1789     c->save();
1790     c->clipOut(bufferRect);
1791     c->clearRect(canvasRect);
1792     c->restore();
1793     c->drawImageBuffer(buffer, bufferRect.location(), state().globalComposite);
1794     c->restore();
1795 }
1796
1797 static void drawImageToContext(Image& image, GraphicsContext& context, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
1798 {
1799     context.drawImage(image, dest, src, op);
1800 }
1801
1802 static void drawImageToContext(ImageBuffer& imageBuffer, GraphicsContext& context, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
1803 {
1804     context.drawImageBuffer(imageBuffer, dest, src, op);
1805 }
1806
1807 template<class T> void CanvasRenderingContext2D::fullCanvasCompositedDrawImage(T& image, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
1808 {
1809     ASSERT(isFullCanvasCompositeMode(op));
1810
1811     IntSize croppedOffset;
1812     auto bufferRect = calculateCompositingBufferRect(dest, &croppedOffset);
1813     if (bufferRect.isEmpty()) {
1814         clearCanvas();
1815         return;
1816     }
1817
1818     auto buffer = createCompositingBuffer(bufferRect);
1819     if (!buffer)
1820         return;
1821
1822     auto* c = drawingContext();
1823     if (!c)
1824         return;
1825
1826     FloatRect adjustedDest = dest;
1827     adjustedDest.setLocation(FloatPoint(0, 0));
1828     AffineTransform effectiveTransform = c->getCTM();
1829     IntRect transformedAdjustedRect = enclosingIntRect(effectiveTransform.mapRect(adjustedDest));
1830     buffer->context().translate(-transformedAdjustedRect.location());
1831     buffer->context().translate(croppedOffset);
1832     buffer->context().concatCTM(effectiveTransform);
1833     drawImageToContext(image, buffer->context(), adjustedDest, src, CompositeSourceOver);
1834
1835     compositeBuffer(*buffer, bufferRect, op);
1836 }
1837
1838 void CanvasRenderingContext2D::prepareGradientForDashboard(CanvasGradient& gradient) const
1839 {
1840 #if ENABLE(DASHBOARD_SUPPORT)
1841     if (m_usesDashboardCompatibilityMode)
1842         gradient.setDashboardCompatibilityMode();
1843 #else
1844     UNUSED_PARAM(gradient);
1845 #endif
1846 }
1847
1848 static CanvasRenderingContext2D::Style toStyle(const CanvasStyle& style)
1849 {
1850     if (auto gradient = style.canvasGradient())
1851         return gradient;
1852     if (auto pattern = style.canvasPattern())
1853         return pattern;
1854     return style.color();
1855 }
1856
1857 CanvasRenderingContext2D::Style CanvasRenderingContext2D::strokeStyle() const
1858 {
1859     return toStyle(state().strokeStyle);
1860 }
1861
1862 void CanvasRenderingContext2D::setStrokeStyle(CanvasRenderingContext2D::Style&& style)
1863 {
1864     WTF::switchOn(style,
1865         [this] (const String& string) { this->setStrokeColor(string); },
1866         [this] (const RefPtr<CanvasGradient>& gradient) { this->setStrokeStyle(CanvasStyle(*gradient)); },
1867         [this] (const RefPtr<CanvasPattern>& pattern) { this->setStrokeStyle(CanvasStyle(*pattern)); }
1868     );
1869 }
1870
1871 CanvasRenderingContext2D::Style CanvasRenderingContext2D::fillStyle() const
1872 {
1873     return toStyle(state().fillStyle);
1874 }
1875
1876 void CanvasRenderingContext2D::setFillStyle(CanvasRenderingContext2D::Style&& style)
1877 {
1878     WTF::switchOn(style,
1879         [this] (const String& string) { this->setFillColor(string); },
1880         [this] (const RefPtr<CanvasGradient>& gradient) { this->setFillStyle(CanvasStyle(*gradient)); },
1881         [this] (const RefPtr<CanvasPattern>& pattern) { this->setFillStyle(CanvasStyle(*pattern)); }
1882     );
1883 }
1884
1885 ExceptionOr<Ref<CanvasGradient>> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)
1886 {
1887     if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(x1) || !std::isfinite(y1))
1888         return Exception { NotSupportedError };
1889
1890     auto gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));
1891     prepareGradientForDashboard(gradient.get());
1892     return WTFMove(gradient);
1893 }
1894
1895 ExceptionOr<Ref<CanvasGradient>> CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1)
1896 {
1897     if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(r0) || !std::isfinite(x1) || !std::isfinite(y1) || !std::isfinite(r1))
1898         return Exception { NotSupportedError };
1899
1900     if (r0 < 0 || r1 < 0)
1901         return Exception { IndexSizeError };
1902
1903     auto gradient = CanvasGradient::create(FloatPoint(x0, y0), r0, FloatPoint(x1, y1), r1);
1904     prepareGradientForDashboard(gradient.get());
1905     return WTFMove(gradient);
1906 }
1907
1908 ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(CanvasImageSource&& image, const String& repetition)
1909 {
1910     bool repeatX, repeatY;
1911     if (!CanvasPattern::parseRepetitionType(repetition, repeatX, repeatY))
1912         return Exception { SyntaxError };
1913
1914     return WTF::switchOn(image,
1915         [&] (auto& element) -> ExceptionOr<RefPtr<CanvasPattern>> { return this->createPattern(*element, repeatX, repeatY); }
1916     );
1917 }
1918
1919 ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(HTMLImageElement& imageElement, bool repeatX, bool repeatY)
1920 {
1921     auto* cachedImage = imageElement.cachedImage();
1922
1923     // If the image loading hasn't started or the image is not complete, it is not fully decodable.
1924     if (!cachedImage || !imageElement.complete())
1925         return nullptr;
1926
1927     if (cachedImage->status() == CachedResource::LoadError)
1928         return Exception { InvalidStateError };
1929
1930     bool originClean = cachedImage->isOriginClean(canvas().securityOrigin());
1931
1932     // FIXME: SVG images with animations can switch between clean and dirty (leaking cross-origin
1933     // data). We should either:
1934     //   1) Take a fixed snapshot of an SVG image when creating a pattern and determine then whether
1935     //      the origin is clean.
1936     //   2) Dynamically verify the origin checks at draw time, and dirty the canvas accordingly.
1937     // To be on the safe side, taint the origin for all patterns containing SVG images for now.
1938     if (cachedImage->image()->isSVGImage())
1939         originClean = false;
1940
1941     return RefPtr<CanvasPattern> { CanvasPattern::create(*cachedImage->imageForRenderer(imageElement.renderer()), repeatX, repeatY, originClean) };
1942 }
1943
1944 ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(HTMLCanvasElement& canvas, bool repeatX, bool repeatY)
1945 {
1946     if (!canvas.width() || !canvas.height() || !canvas.buffer())
1947         return Exception { InvalidStateError };
1948
1949     return RefPtr<CanvasPattern> { CanvasPattern::create(*canvas.copiedImage(), repeatX, repeatY, canvas.originClean()) };
1950 }
1951     
1952 #if ENABLE(VIDEO)
1953
1954 ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(HTMLVideoElement& videoElement, bool repeatX, bool repeatY)
1955 {
1956     if (videoElement.readyState() < HTMLMediaElement::HAVE_CURRENT_DATA)
1957         return nullptr;
1958     
1959     checkOrigin(&videoElement);
1960     bool originClean = canvas().originClean();
1961
1962 #if USE(CG) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(GSTREAMER_GL) && USE(CAIRO))
1963     if (auto nativeImage = videoElement.nativeImageForCurrentTime())
1964         return RefPtr<CanvasPattern> { CanvasPattern::create(BitmapImage::create(WTFMove(nativeImage)), repeatX, repeatY, originClean) };
1965 #endif
1966
1967     auto imageBuffer = ImageBuffer::create(size(videoElement), drawingContext() ? drawingContext()->renderingMode() : Accelerated);
1968     videoElement.paintCurrentFrameInContext(imageBuffer->context(), FloatRect(FloatPoint(), size(videoElement)));
1969     
1970     return RefPtr<CanvasPattern> { CanvasPattern::create(ImageBuffer::sinkIntoImage(WTFMove(imageBuffer), Unscaled).releaseNonNull(), repeatX, repeatY, originClean) };
1971 }
1972
1973 #endif
1974
1975 ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(ImageBitmap&, bool, bool)
1976 {
1977     // FIXME: Implement.
1978     return Exception { TypeError };
1979 }
1980
1981 void CanvasRenderingContext2D::didDrawEntireCanvas()
1982 {
1983     didDraw(FloatRect(FloatPoint::zero(), canvas().size()), CanvasDidDrawApplyClip);
1984 }
1985
1986 void CanvasRenderingContext2D::didDraw(const FloatRect& r, unsigned options)
1987 {
1988     auto* c = drawingContext();
1989     if (!c)
1990         return;
1991     if (!state().hasInvertibleTransform)
1992         return;
1993
1994 #if ENABLE(ACCELERATED_2D_CANVAS)
1995     // If we are drawing to hardware and we have a composited layer, just call contentChanged().
1996     if (isAccelerated()) {
1997         RenderBox* renderBox = canvas().renderBox();
1998         if (renderBox && renderBox->hasAcceleratedCompositing()) {
1999             renderBox->contentChanged(CanvasPixelsChanged);
2000             canvas().clearCopiedImage();
2001             canvas().notifyObserversCanvasChanged(r);
2002             return;
2003         }
2004     }
2005 #endif
2006
2007     FloatRect dirtyRect = r;
2008     if (options & CanvasDidDrawApplyTransform) {
2009         AffineTransform ctm = state().transform;
2010         dirtyRect = ctm.mapRect(r);
2011     }
2012
2013     if (options & CanvasDidDrawApplyShadow && state().shadowColor.isVisible()) {
2014         // The shadow gets applied after transformation
2015         FloatRect shadowRect(dirtyRect);
2016         shadowRect.move(state().shadowOffset);
2017         shadowRect.inflate(state().shadowBlur);
2018         dirtyRect.unite(shadowRect);
2019     }
2020
2021     if (options & CanvasDidDrawApplyClip) {
2022         // FIXME: apply the current clip to the rectangle. Unfortunately we can't get the clip
2023         // back out of the GraphicsContext, so to take clip into account for incremental painting,
2024         // we'd have to keep the clip path around.
2025     }
2026
2027     canvas().didDraw(dirtyRect);
2028 }
2029
2030 void CanvasRenderingContext2D::setTracksDisplayListReplay(bool tracksDisplayListReplay)
2031 {
2032     if (tracksDisplayListReplay == m_tracksDisplayListReplay)
2033         return;
2034
2035     m_tracksDisplayListReplay = tracksDisplayListReplay;
2036     if (!m_tracksDisplayListReplay)
2037         contextDisplayListMap().remove(this);
2038 }
2039
2040 String CanvasRenderingContext2D::displayListAsText(DisplayList::AsTextFlags flags) const
2041 {
2042     if (!m_recordingContext)
2043         return { };
2044     return m_recordingContext->displayList.asText(flags);
2045 }
2046
2047 String CanvasRenderingContext2D::replayDisplayListAsText(DisplayList::AsTextFlags flags) const
2048 {
2049     auto* displayList = contextDisplayListMap().get(this);
2050     if (!displayList)
2051         return { };
2052     return displayList->asText(flags);
2053 }
2054
2055 void CanvasRenderingContext2D::paintRenderingResultsToCanvas()
2056 {
2057     if (UNLIKELY(m_usesDisplayListDrawing)) {
2058         if (!m_recordingContext)
2059             return;
2060
2061         FloatRect clip(FloatPoint::zero(), canvas().size());
2062         DisplayList::Replayer replayer(*canvas().drawingContext(), m_recordingContext->displayList);
2063
2064         if (UNLIKELY(m_tracksDisplayListReplay)) {
2065             auto replayList = replayer.replay(clip, m_tracksDisplayListReplay);
2066             contextDisplayListMap().add(this, WTFMove(replayList));
2067         } else
2068             replayer.replay(clip);
2069
2070         m_recordingContext->displayList.clear();
2071     }
2072 }
2073
2074 GraphicsContext* CanvasRenderingContext2D::drawingContext() const
2075 {
2076     if (UNLIKELY(m_usesDisplayListDrawing)) {
2077         if (!m_recordingContext)
2078             m_recordingContext = std::make_unique<DisplayListDrawingContext>(FloatRect(FloatPoint::zero(), canvas().size()));
2079         return &m_recordingContext->context;
2080     }
2081
2082     return canvas().drawingContext();
2083 }
2084
2085 static RefPtr<ImageData> createEmptyImageData(const IntSize& size)
2086 {
2087     auto data = ImageData::create(size);
2088     if (data)
2089         data->data()->zeroFill();
2090     return data;
2091 }
2092
2093 ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::createImageData(ImageData* imageData) const
2094 {
2095     if (!imageData)
2096         return Exception { NotSupportedError };
2097
2098     return createEmptyImageData(imageData->size());
2099 }
2100
2101 ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::createImageData(float sw, float sh) const
2102 {
2103     if (!sw || !sh)
2104         return Exception { IndexSizeError };
2105
2106     FloatSize logicalSize(std::abs(sw), std::abs(sh));
2107     if (!logicalSize.isExpressibleAsIntSize())
2108         return nullptr;
2109
2110     IntSize size = expandedIntSize(logicalSize);
2111     if (size.width() < 1)
2112         size.setWidth(1);
2113     if (size.height() < 1)
2114         size.setHeight(1);
2115
2116     return createEmptyImageData(size);
2117 }
2118
2119 ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh) const
2120 {
2121     return getImageData(ImageBuffer::LogicalCoordinateSystem, sx, sy, sw, sh);
2122 }
2123
2124 ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::webkitGetImageDataHD(float sx, float sy, float sw, float sh) const
2125 {
2126     return getImageData(ImageBuffer::BackingStoreCoordinateSystem, sx, sy, sw, sh);
2127 }
2128
2129 ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::getImageData(ImageBuffer::CoordinateSystem coordinateSystem, float sx, float sy, float sw, float sh) const
2130 {
2131     if (!canvas().originClean()) {
2132         static NeverDestroyed<String> consoleMessage(MAKE_STATIC_STRING_IMPL("Unable to get image data from canvas because the canvas has been tainted by cross-origin data."));
2133         canvas().document().addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage);
2134         return Exception { SecurityError };
2135     }
2136
2137     if (!sw || !sh)
2138         return Exception { IndexSizeError };
2139
2140     if (sw < 0) {
2141         sx += sw;
2142         sw = -sw;
2143     }    
2144     if (sh < 0) {
2145         sy += sh;
2146         sh = -sh;
2147     }
2148
2149     FloatRect logicalRect(sx, sy, sw, sh);
2150     if (logicalRect.width() < 1)
2151         logicalRect.setWidth(1);
2152     if (logicalRect.height() < 1)
2153         logicalRect.setHeight(1);
2154     if (!logicalRect.isExpressibleAsIntRect())
2155         return nullptr;
2156
2157     IntRect imageDataRect = enclosingIntRect(logicalRect);
2158     ImageBuffer* buffer = canvas().buffer();
2159     if (!buffer)
2160         return createEmptyImageData(imageDataRect.size());
2161
2162     auto byteArray = buffer->getUnmultipliedImageData(imageDataRect, nullptr, coordinateSystem);
2163     if (!byteArray) {
2164         StringBuilder consoleMessage;
2165         consoleMessage.appendLiteral("Unable to get image data from canvas. Requested size was ");
2166         consoleMessage.appendNumber(imageDataRect.width());
2167         consoleMessage.appendLiteral(" x ");
2168         consoleMessage.appendNumber(imageDataRect.height());
2169
2170         canvas().document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, consoleMessage.toString());
2171         return Exception { InvalidStateError };
2172     }
2173
2174     return ImageData::create(imageDataRect.size(), byteArray.releaseNonNull());
2175 }
2176
2177 void CanvasRenderingContext2D::putImageData(ImageData& data, float dx, float dy)
2178 {
2179     putImageData(data, dx, dy, 0, 0, data.width(), data.height());
2180 }
2181
2182 void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData& data, float dx, float dy)
2183 {
2184     webkitPutImageDataHD(data, dx, dy, 0, 0, data.width(), data.height());
2185 }
2186
2187 void CanvasRenderingContext2D::putImageData(ImageData& data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)
2188 {
2189     putImageData(data, ImageBuffer::LogicalCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);
2190 }
2191
2192 void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData& data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)
2193 {
2194     putImageData(data, ImageBuffer::BackingStoreCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);
2195 }
2196
2197 void CanvasRenderingContext2D::drawFocusIfNeeded(Element& element)
2198 {
2199     drawFocusIfNeededInternal(m_path, element);
2200 }
2201
2202 void CanvasRenderingContext2D::drawFocusIfNeeded(Path2D& path, Element& element)
2203 {
2204     drawFocusIfNeededInternal(path.path(), element);
2205 }
2206
2207 void CanvasRenderingContext2D::drawFocusIfNeededInternal(const Path& path, Element& element)
2208 {
2209     auto* context = drawingContext();
2210     if (!element.focused() || !state().hasInvertibleTransform || path.isEmpty() || !element.isDescendantOf(canvas()) || !context)
2211         return;
2212     context->drawFocusRing(path, 1, 1, RenderTheme::focusRingColor());
2213 }
2214
2215 void CanvasRenderingContext2D::putImageData(ImageData& data, ImageBuffer::CoordinateSystem coordinateSystem, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)
2216 {
2217     ImageBuffer* buffer = canvas().buffer();
2218     if (!buffer)
2219         return;
2220
2221     if (dirtyWidth < 0) {
2222         dirtyX += dirtyWidth;
2223         dirtyWidth = -dirtyWidth;
2224     }
2225
2226     if (dirtyHeight < 0) {
2227         dirtyY += dirtyHeight;
2228         dirtyHeight = -dirtyHeight;
2229     }
2230
2231     FloatRect clipRect(dirtyX, dirtyY, dirtyWidth, dirtyHeight);
2232     clipRect.intersect(IntRect(0, 0, data.width(), data.height()));
2233     IntSize destOffset(static_cast<int>(dx), static_cast<int>(dy));
2234     IntRect destRect = enclosingIntRect(clipRect);
2235     destRect.move(destOffset);
2236     destRect.intersect(IntRect(IntPoint(), coordinateSystem == ImageBuffer::LogicalCoordinateSystem ? buffer->logicalSize() : buffer->internalSize()));
2237     if (destRect.isEmpty())
2238         return;
2239     IntRect sourceRect(destRect);
2240     sourceRect.move(-destOffset);
2241     sourceRect.intersect(IntRect(0, 0, data.width(), data.height()));
2242
2243     if (!sourceRect.isEmpty())
2244         buffer->putByteArray(Unmultiplied, data.data(), IntSize(data.width(), data.height()), sourceRect, IntPoint(destOffset), coordinateSystem);
2245
2246     didDraw(destRect, CanvasDidDrawApplyNone); // ignore transform, shadow and clip
2247 }
2248
2249 String CanvasRenderingContext2D::font() const
2250 {
2251     if (!state().font.realized())
2252         return defaultFont;
2253
2254     StringBuilder serializedFont;
2255     const auto& fontDescription = state().font.fontDescription();
2256
2257     if (fontDescription.italic())
2258         serializedFont.appendLiteral("italic ");
2259     if (fontDescription.variantCaps() == FontVariantCaps::Small)
2260         serializedFont.appendLiteral("small-caps ");
2261
2262     serializedFont.appendNumber(fontDescription.computedPixelSize());
2263     serializedFont.appendLiteral("px");
2264
2265     for (unsigned i = 0; i < fontDescription.familyCount(); ++i) {
2266         if (i)
2267             serializedFont.append(',');
2268         // FIXME: We should append family directly to serializedFont rather than building a temporary string.
2269         String family = fontDescription.familyAt(i);
2270         if (family.startsWith("-webkit-"))
2271             family = family.substring(8);
2272         if (family.contains(' '))
2273             family = makeString('"', family, '"');
2274
2275         serializedFont.append(' ');
2276         serializedFont.append(family);
2277     }
2278
2279     return serializedFont.toString();
2280 }
2281
2282 void CanvasRenderingContext2D::setFont(const String& newFont)
2283 {
2284     if (newFont == state().unparsedFont && state().font.realized())
2285         return;
2286
2287     auto parsedStyle = MutableStyleProperties::create();
2288     CSSParser::parseValue(parsedStyle, CSSPropertyFont, newFont, true, strictToCSSParserMode(!m_usesCSSCompatibilityParseMode));
2289     if (parsedStyle->isEmpty())
2290         return;
2291
2292     String fontValue = parsedStyle->getPropertyValue(CSSPropertyFont);
2293
2294     // According to http://lists.w3.org/Archives/Public/public-html/2009Jul/0947.html,
2295     // the "inherit" and "initial" values must be ignored.
2296     if (fontValue == "inherit" || fontValue == "initial")
2297         return;
2298
2299     // The parse succeeded.
2300     String newFontSafeCopy(newFont); // Create a string copy since newFont can be deleted inside realizeSaves.
2301     realizeSaves();
2302     modifiableState().unparsedFont = newFontSafeCopy;
2303
2304     // Map the <canvas> font into the text style. If the font uses keywords like larger/smaller, these will work
2305     // relative to the canvas.
2306     auto newStyle = RenderStyle::createPtr();
2307
2308     Document& document = canvas().document();
2309     document.updateStyleIfNeeded();
2310
2311     if (auto* computedStyle = canvas().computedStyle())
2312         newStyle->setFontDescription(computedStyle->fontDescription());
2313     else {
2314         FontCascadeDescription defaultFontDescription;
2315         defaultFontDescription.setOneFamily(defaultFontFamily);
2316         defaultFontDescription.setSpecifiedSize(defaultFontSize);
2317         defaultFontDescription.setComputedSize(defaultFontSize);
2318
2319         newStyle->setFontDescription(defaultFontDescription);
2320     }
2321
2322     newStyle->fontCascade().update(&document.fontSelector());
2323
2324     // Now map the font property longhands into the style.
2325     StyleResolver& styleResolver = canvas().styleResolver();
2326     styleResolver.applyPropertyToStyle(CSSPropertyFontFamily, parsedStyle->getPropertyCSSValue(CSSPropertyFontFamily).get(), WTFMove(newStyle));
2327     styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontStyle, parsedStyle->getPropertyCSSValue(CSSPropertyFontStyle).get());
2328     styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontVariantCaps, parsedStyle->getPropertyCSSValue(CSSPropertyFontVariantCaps).get());
2329     styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontWeight, parsedStyle->getPropertyCSSValue(CSSPropertyFontWeight).get());
2330
2331     // As described in BUG66291, setting font-size and line-height on a font may entail a CSSPrimitiveValue::computeLengthDouble call,
2332     // which assumes the fontMetrics are available for the affected font, otherwise a crash occurs (see http://trac.webkit.org/changeset/96122).
2333     // The updateFont() calls below update the fontMetrics and ensure the proper setting of font-size and line-height.
2334     styleResolver.updateFont();
2335     styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontSize, parsedStyle->getPropertyCSSValue(CSSPropertyFontSize).get());
2336     styleResolver.updateFont();
2337     styleResolver.applyPropertyToCurrentStyle(CSSPropertyLineHeight, parsedStyle->getPropertyCSSValue(CSSPropertyLineHeight).get());
2338
2339     modifiableState().font.initialize(document.fontSelector(), *styleResolver.style());
2340 }
2341
2342 static CanvasTextAlign toCanvasTextAlign(TextAlign textAlign)
2343 {
2344     switch (textAlign) {
2345     case StartTextAlign:
2346         return CanvasTextAlign::Start;
2347     case EndTextAlign:
2348         return CanvasTextAlign::End;
2349     case LeftTextAlign:
2350         return CanvasTextAlign::Left;
2351     case RightTextAlign:
2352         return CanvasTextAlign::Right;
2353     case CenterTextAlign:
2354         return CanvasTextAlign::Center;
2355     }
2356
2357     ASSERT_NOT_REACHED();
2358     return CanvasTextAlign::Start;
2359 }
2360
2361 static TextAlign fromCanvasTextAlign(CanvasTextAlign canvasTextAlign)
2362 {
2363     switch (canvasTextAlign) {
2364     case CanvasTextAlign::Start:
2365         return StartTextAlign;
2366     case CanvasTextAlign::End:
2367         return EndTextAlign;
2368     case CanvasTextAlign::Left:
2369         return LeftTextAlign;
2370     case CanvasTextAlign::Right:
2371         return RightTextAlign;
2372     case CanvasTextAlign::Center:
2373         return CenterTextAlign;
2374     }
2375
2376     ASSERT_NOT_REACHED();
2377     return StartTextAlign;
2378 }
2379
2380 CanvasTextAlign CanvasRenderingContext2D::textAlign() const
2381 {
2382     return toCanvasTextAlign(state().textAlign);
2383 }
2384
2385 void CanvasRenderingContext2D::setTextAlign(CanvasTextAlign canvasTextAlign)
2386 {
2387     auto textAlign = fromCanvasTextAlign(canvasTextAlign);
2388     if (state().textAlign == textAlign)
2389         return;
2390     realizeSaves();
2391     modifiableState().textAlign = textAlign;
2392 }
2393
2394 static CanvasTextBaseline toCanvasTextBaseline(TextBaseline textBaseline)
2395 {
2396     switch (textBaseline) {
2397     case TopTextBaseline:
2398         return CanvasTextBaseline::Top;
2399     case HangingTextBaseline:
2400         return CanvasTextBaseline::Hanging;
2401     case MiddleTextBaseline:
2402         return CanvasTextBaseline::Middle;
2403     case AlphabeticTextBaseline:
2404         return CanvasTextBaseline::Alphabetic;
2405     case IdeographicTextBaseline:
2406         return CanvasTextBaseline::Ideographic;
2407     case BottomTextBaseline:
2408         return CanvasTextBaseline::Bottom;
2409     }
2410
2411     ASSERT_NOT_REACHED();
2412     return CanvasTextBaseline::Top;
2413 }
2414
2415 static TextBaseline fromCanvasTextBaseline(CanvasTextBaseline canvasTextBaseline)
2416 {
2417     switch (canvasTextBaseline) {
2418     case CanvasTextBaseline::Top:
2419         return TopTextBaseline;
2420     case CanvasTextBaseline::Hanging:
2421         return HangingTextBaseline;
2422     case CanvasTextBaseline::Middle:
2423         return MiddleTextBaseline;
2424     case CanvasTextBaseline::Alphabetic:
2425         return AlphabeticTextBaseline;
2426     case CanvasTextBaseline::Ideographic:
2427         return IdeographicTextBaseline;
2428     case CanvasTextBaseline::Bottom:
2429         return BottomTextBaseline;
2430     }
2431
2432     ASSERT_NOT_REACHED();
2433     return TopTextBaseline;
2434 }
2435
2436 CanvasTextBaseline CanvasRenderingContext2D::textBaseline() const
2437 {
2438     return toCanvasTextBaseline(state().textBaseline);
2439 }
2440
2441 void CanvasRenderingContext2D::setTextBaseline(CanvasTextBaseline canvasTextBaseline)
2442 {
2443     auto textBaseline = fromCanvasTextBaseline(canvasTextBaseline);
2444     if (state().textBaseline == textBaseline)
2445         return;
2446     realizeSaves();
2447     modifiableState().textBaseline = textBaseline;
2448 }
2449
2450 inline TextDirection CanvasRenderingContext2D::toTextDirection(Direction direction, const RenderStyle** computedStyle) const
2451 {
2452     auto* style = (computedStyle || direction == Direction::Inherit) ? canvas().computedStyle() : nullptr;
2453     if (computedStyle)
2454         *computedStyle = style;
2455     switch (direction) {
2456     case Direction::Inherit:
2457         return style ? style->direction() : LTR;
2458     case Direction::Rtl:
2459         return RTL;
2460     case Direction::Ltr:
2461         return LTR;
2462     }
2463     ASSERT_NOT_REACHED();
2464     return LTR;
2465 }
2466
2467 CanvasDirection CanvasRenderingContext2D::direction() const
2468 {
2469     if (state().direction == Direction::Inherit)
2470         canvas().document().updateStyleIfNeeded();
2471     return toTextDirection(state().direction) == RTL ? CanvasDirection::Rtl : CanvasDirection::Ltr;
2472 }
2473
2474 void CanvasRenderingContext2D::setDirection(CanvasDirection direction)
2475 {
2476     if (state().direction == direction)
2477         return;
2478
2479     realizeSaves();
2480     modifiableState().direction = direction;
2481 }
2482
2483 void CanvasRenderingContext2D::fillText(const String& text, float x, float y, std::optional<float> maxWidth)
2484 {
2485     drawTextInternal(text, x, y, true, maxWidth);
2486 }
2487
2488 void CanvasRenderingContext2D::strokeText(const String& text, float x, float y, std::optional<float> maxWidth)
2489 {
2490     drawTextInternal(text, x, y, false, maxWidth);
2491 }
2492
2493 static inline bool isSpaceThatNeedsReplacing(UChar c)
2494 {
2495     // According to specification all space characters should be replaced with 0x0020 space character.
2496     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#text-preparation-algorithm
2497     // The space characters according to specification are : U+0020, U+0009, U+000A, U+000C, and U+000D.
2498     // http://www.whatwg.org/specs/web-apps/current-work/multipage/common-microsyntaxes.html#space-character
2499     // This function returns true for 0x000B also, so that this is backward compatible.
2500     // Otherwise, the test LayoutTests/canvas/philip/tests/2d.text.draw.space.collapse.space.html will fail
2501     return c == 0x0009 || c == 0x000A || c == 0x000B || c == 0x000C || c == 0x000D;
2502 }
2503
2504 static void normalizeSpaces(String& text)
2505 {
2506     size_t i = text.find(isSpaceThatNeedsReplacing);
2507     if (i == notFound)
2508         return;
2509
2510     unsigned textLength = text.length();
2511     StringVector<UChar> charVector(textLength);
2512     StringView(text).getCharactersWithUpconvert(charVector.data());
2513
2514     charVector[i++] = ' ';
2515
2516     for (; i < textLength; ++i) {
2517         if (isSpaceThatNeedsReplacing(charVector[i]))
2518             charVector[i] = ' ';
2519     }
2520     text = String::adopt(WTFMove(charVector));
2521 }
2522
2523 Ref<TextMetrics> CanvasRenderingContext2D::measureText(const String& text)
2524 {
2525     Ref<TextMetrics> metrics = TextMetrics::create();
2526
2527     String normalizedText = text;
2528     normalizeSpaces(normalizedText);
2529
2530     const RenderStyle* computedStyle;
2531     auto direction = toTextDirection(state().direction, &computedStyle);
2532     bool override = computedStyle ? isOverride(computedStyle->unicodeBidi()) : false;
2533
2534     TextRun textRun(normalizedText, 0, 0, AllowTrailingExpansion, direction, override, true);
2535     auto& font = fontProxy();
2536     auto& fontMetrics = font.fontMetrics();
2537
2538     GlyphOverflow glyphOverflow;
2539     glyphOverflow.computeBounds = true;
2540     float fontWidth = font.width(textRun, &glyphOverflow);
2541     metrics->setWidth(fontWidth);
2542
2543     FloatPoint offset = textOffset(fontWidth, direction);
2544
2545     metrics->setActualBoundingBoxAscent(glyphOverflow.top - offset.y());
2546     metrics->setActualBoundingBoxDescent(glyphOverflow.bottom + offset.y());
2547     metrics->setFontBoundingBoxAscent(fontMetrics.ascent() - offset.y());
2548     metrics->setFontBoundingBoxDescent(fontMetrics.descent() + offset.y());
2549     metrics->setEmHeightAscent(fontMetrics.ascent() - offset.y());
2550     metrics->setEmHeightDescent(fontMetrics.descent() + offset.y());
2551     metrics->setHangingBaseline(fontMetrics.ascent() - offset.y());
2552     metrics->setAlphabeticBaseline(-offset.y());
2553     metrics->setIdeographicBaseline(-fontMetrics.descent() - offset.y());
2554
2555     metrics->setActualBoundingBoxLeft(glyphOverflow.left - offset.x());
2556     metrics->setActualBoundingBoxRight(fontWidth + glyphOverflow.right + offset.x());
2557
2558     return metrics;
2559 }
2560
2561 FloatPoint CanvasRenderingContext2D::textOffset(float width, TextDirection direction)
2562 {
2563     auto& fontMetrics = fontProxy().fontMetrics();
2564     FloatPoint offset;
2565
2566     switch (state().textBaseline) {
2567     case TopTextBaseline:
2568     case HangingTextBaseline:
2569         offset.setY(fontMetrics.ascent());
2570         break;
2571     case BottomTextBaseline:
2572     case IdeographicTextBaseline:
2573         offset.setY(-fontMetrics.descent());
2574         break;
2575     case MiddleTextBaseline:
2576         offset.setY(fontMetrics.height() / 2 - fontMetrics.descent());
2577         break;
2578     case AlphabeticTextBaseline:
2579     default:
2580         break;
2581     }
2582
2583     bool isRTL = direction == RTL;
2584     auto align = state().textAlign;
2585     if (align == StartTextAlign)
2586         align = isRTL ? RightTextAlign : LeftTextAlign;
2587     else if (align == EndTextAlign)
2588         align = isRTL ? LeftTextAlign : RightTextAlign;
2589
2590     switch (align) {
2591     case CenterTextAlign:
2592         offset.setX(-width / 2);
2593         break;
2594     case RightTextAlign:
2595         offset.setX(-width);
2596         break;
2597     default:
2598         break;
2599     }
2600     return offset;
2601 }
2602
2603 void CanvasRenderingContext2D::drawTextInternal(const String& text, float x, float y, bool fill, std::optional<float> maxWidth)
2604 {
2605     auto& fontProxy = this->fontProxy();
2606     const auto& fontMetrics = fontProxy.fontMetrics();
2607
2608     auto* c = drawingContext();
2609     if (!c)
2610         return;
2611     if (!state().hasInvertibleTransform)
2612         return;
2613     if (!std::isfinite(x) | !std::isfinite(y))
2614         return;
2615     if (maxWidth && (!std::isfinite(maxWidth.value()) || maxWidth.value() <= 0))
2616         return;
2617
2618     // If gradient size is zero, then paint nothing.
2619     auto gradient = c->strokeGradient();
2620     if (!fill && gradient && gradient->isZeroSize())
2621         return;
2622
2623     gradient = c->fillGradient();
2624     if (fill && gradient && gradient->isZeroSize())
2625         return;
2626
2627     String normalizedText = text;
2628     normalizeSpaces(normalizedText);
2629
2630     // FIXME: Need to turn off font smoothing.
2631
2632     const RenderStyle* computedStyle;
2633     auto direction = toTextDirection(state().direction, &computedStyle);
2634     bool override = computedStyle ? isOverride(computedStyle->unicodeBidi()) : false;
2635
2636     TextRun textRun(normalizedText, 0, 0, AllowTrailingExpansion, direction, override, true);
2637     float fontWidth = fontProxy.width(textRun);
2638     bool useMaxWidth = maxWidth && maxWidth.value() < fontWidth;
2639     float width = useMaxWidth ? maxWidth.value() : fontWidth;
2640     FloatPoint location(x, y);
2641     location += textOffset(width, direction);
2642
2643     // The slop built in to this mask rect matches the heuristic used in FontCGWin.cpp for GDI text.
2644     FloatRect textRect = FloatRect(location.x() - fontMetrics.height() / 2, location.y() - fontMetrics.ascent() - fontMetrics.lineGap(),
2645         width + fontMetrics.height(), fontMetrics.lineSpacing());
2646     if (!fill)
2647         inflateStrokeRect(textRect);
2648
2649 #if USE(CG)
2650     const CanvasStyle& drawStyle = fill ? state().fillStyle : state().strokeStyle;
2651     if (drawStyle.canvasGradient() || drawStyle.canvasPattern()) {
2652         IntRect maskRect = enclosingIntRect(textRect);
2653
2654         // If we have a shadow, we need to draw it before the mask operation.
2655         // Follow a procedure similar to paintTextWithShadows in TextPainter.
2656
2657         if (shouldDrawShadows()) {
2658             GraphicsContextStateSaver stateSaver(*c);
2659
2660             FloatSize offset(0, 2 * maskRect.height());
2661
2662             FloatSize shadowOffset;
2663             float shadowRadius;
2664             Color shadowColor;
2665             c->getShadow(shadowOffset, shadowRadius, shadowColor);
2666
2667             FloatRect shadowRect(maskRect);
2668             shadowRect.inflate(shadowRadius * 1.4);
2669             shadowRect.move(shadowOffset * -1);
2670             c->clip(shadowRect);
2671
2672             shadowOffset += offset;
2673
2674             c->setLegacyShadow(shadowOffset, shadowRadius, shadowColor);
2675
2676             if (fill)
2677                 c->setFillColor(Color::black);
2678             else
2679                 c->setStrokeColor(Color::black);
2680
2681             fontProxy.drawBidiText(*c, textRun, location + offset, FontCascade::UseFallbackIfFontNotReady);
2682         }
2683
2684         auto maskImage = ImageBuffer::createCompatibleBuffer(maskRect.size(), ColorSpaceSRGB, *c);
2685         if (!maskImage)
2686             return;
2687
2688         auto& maskImageContext = maskImage->context();
2689
2690         if (fill)
2691             maskImageContext.setFillColor(Color::black);
2692         else {
2693             maskImageContext.setStrokeColor(Color::black);
2694             maskImageContext.setStrokeThickness(c->strokeThickness());
2695         }
2696
2697         maskImageContext.setTextDrawingMode(fill ? TextModeFill : TextModeStroke);
2698
2699         if (useMaxWidth) {
2700             maskImageContext.translate(location - maskRect.location());
2701             // We draw when fontWidth is 0 so compositing operations (eg, a "copy" op) still work.
2702             maskImageContext.scale(FloatSize((fontWidth > 0 ? (width / fontWidth) : 0), 1));
2703             fontProxy.drawBidiText(maskImageContext, textRun, FloatPoint(0, 0), FontCascade::UseFallbackIfFontNotReady);
2704         } else {
2705             maskImageContext.translate(-maskRect.location());
2706             fontProxy.drawBidiText(maskImageContext, textRun, location, FontCascade::UseFallbackIfFontNotReady);
2707         }
2708
2709         GraphicsContextStateSaver stateSaver(*c);
2710         c->clipToImageBuffer(*maskImage, maskRect);
2711         drawStyle.applyFillColor(*c);
2712         c->fillRect(maskRect);
2713         return;
2714     }
2715 #endif
2716
2717     c->setTextDrawingMode(fill ? TextModeFill : TextModeStroke);
2718
2719     GraphicsContextStateSaver stateSaver(*c);
2720     if (useMaxWidth) {
2721         c->translate(location);
2722         // We draw when fontWidth is 0 so compositing operations (eg, a "copy" op) still work.
2723         c->scale(FloatSize((fontWidth > 0 ? (width / fontWidth) : 0), 1));
2724         location = FloatPoint();
2725     }
2726
2727     if (isFullCanvasCompositeMode(state().globalComposite)) {
2728         beginCompositeLayer();
2729         fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
2730         endCompositeLayer();
2731         didDrawEntireCanvas();
2732     } else if (state().globalComposite == CompositeCopy) {
2733         clearCanvas();
2734         fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
2735         didDrawEntireCanvas();
2736     } else {
2737         fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
2738         didDraw(textRect);
2739     }
2740 }
2741
2742 void CanvasRenderingContext2D::inflateStrokeRect(FloatRect& rect) const
2743 {
2744     // Fast approximation of the stroke's bounding rect.
2745     // This yields a slightly oversized rect but is very fast
2746     // compared to Path::strokeBoundingRect().
2747     static const float root2 = sqrtf(2);
2748     float delta = state().lineWidth / 2;
2749     if (state().lineJoin == MiterJoin)
2750         delta *= state().miterLimit;
2751     else if (state().lineCap == SquareCap)
2752         delta *= root2;
2753     rect.inflate(delta);
2754 }
2755
2756 auto CanvasRenderingContext2D::fontProxy() -> const FontProxy&
2757 {
2758     canvas().document().updateStyleIfNeeded();
2759     if (!state().font.realized())
2760         setFont(state().unparsedFont);
2761     return state().font;
2762 }
2763
2764 #if ENABLE(ACCELERATED_2D_CANVAS)
2765
2766 PlatformLayer* CanvasRenderingContext2D::platformLayer() const
2767 {
2768     return canvas().buffer() ? canvas().buffer()->platformLayer() : nullptr;
2769 }
2770
2771 #endif
2772
2773 static inline InterpolationQuality smoothingToInterpolationQuality(ImageSmoothingQuality quality)
2774 {
2775     switch (quality) {
2776     case ImageSmoothingQuality::Low:
2777         return InterpolationLow;
2778     case ImageSmoothingQuality::Medium:
2779         return InterpolationMedium;
2780     case ImageSmoothingQuality::High:
2781         return InterpolationHigh;
2782     }
2783
2784     ASSERT_NOT_REACHED();
2785     return InterpolationLow;
2786 };
2787
2788 auto CanvasRenderingContext2D::imageSmoothingQuality() const -> ImageSmoothingQuality
2789 {
2790     return state().imageSmoothingQuality;
2791 }
2792
2793 void CanvasRenderingContext2D::setImageSmoothingQuality(ImageSmoothingQuality quality)
2794 {
2795     if (quality == state().imageSmoothingQuality)
2796         return;
2797
2798     realizeSaves();
2799     modifiableState().imageSmoothingQuality = quality;
2800
2801     if (!state().imageSmoothingEnabled)
2802         return;
2803
2804     if (auto* context = drawingContext())
2805         context->setImageInterpolationQuality(smoothingToInterpolationQuality(quality));
2806 }
2807
2808 bool CanvasRenderingContext2D::imageSmoothingEnabled() const
2809 {
2810     return state().imageSmoothingEnabled;
2811 }
2812
2813 void CanvasRenderingContext2D::setImageSmoothingEnabled(bool enabled)
2814 {
2815     if (enabled == state().imageSmoothingEnabled)
2816         return;
2817
2818     realizeSaves();
2819     modifiableState().imageSmoothingEnabled = enabled;
2820     auto* c = drawingContext();
2821     if (c)
2822         c->setImageInterpolationQuality(enabled ? smoothingToInterpolationQuality(state().imageSmoothingQuality) : InterpolationNone);
2823 }
2824
2825 void CanvasRenderingContext2D::setPath(Path2D& path)
2826 {
2827     m_path = path.path();
2828 }
2829
2830 Ref<Path2D> CanvasRenderingContext2D::getPath() const
2831 {
2832     return Path2D::create(m_path);
2833 }
2834
2835 } // namespace WebCore