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