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