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