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