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