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