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