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