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