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