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