<rdar://problem/5974306> CanvasRenderingContext2D becomes invalid when source canvas...
[WebKit-https.git] / WebCore / html / CanvasRenderingContext2D.cpp
1 /*
2  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2007 Trolltech ASA
4  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
26  */
27
28 #include "config.h"
29 #include "CanvasRenderingContext2D.h"
30
31 #include "AffineTransform.h"
32 #include "CSSParser.h"
33 #include "CachedImage.h"
34 #include "CanvasGradient.h"
35 #include "CanvasPattern.h"
36 #include "CanvasPixelArray.h"
37 #include "CanvasStyle.h"
38 #include "Document.h"
39 #include "ExceptionCode.h"
40 #include "FloatConversion.h"
41 #include "Frame.h"
42 #include "GraphicsContext.h"
43 #include "HTMLCanvasElement.h"
44 #include "HTMLImageElement.h"
45 #include "HTMLNames.h"
46 #include "ImageBuffer.h"
47 #include "ImageData.h"
48 #include "KURL.h"
49 #include "NotImplemented.h"
50 #include "Page.h"
51 #include "RenderHTMLCanvas.h"
52 #include "SecurityOrigin.h"
53 #include "Settings.h"
54 #include <kjs/interpreter.h>
55 #include <stdio.h>
56 #include <wtf/MathExtras.h>
57
58 #if PLATFORM(QT)
59 #include <QPainter>
60 #include <QPixmap>
61 #include <QPainterPath>
62 #elif PLATFORM(CAIRO)
63 #include "CairoPath.h"
64 #include <cairo.h>
65 #endif
66
67 namespace WebCore {
68
69 using namespace HTMLNames;
70
71 CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement* canvas)
72     : m_canvas(canvas)
73     , m_stateStack(1)
74 {
75 }
76
77 void CanvasRenderingContext2D::ref()
78 {
79 m_canvas->ref();
80 }
81
82 void CanvasRenderingContext2D::deref()
83 {
84     m_canvas->deref(); 
85 }
86
87 void CanvasRenderingContext2D::reset()
88 {
89     m_stateStack.resize(1);
90     m_stateStack.first() = State();
91 }
92
93 CanvasRenderingContext2D::State::State()
94     : m_strokeStyle(CanvasStyle::create("black"))
95     , m_fillStyle(CanvasStyle::create("black"))
96     , m_lineWidth(1)
97     , m_lineCap(ButtCap)
98     , m_lineJoin(MiterJoin)
99     , m_miterLimit(10)
100     , m_shadowBlur(0)
101     , m_shadowColor("black")
102     , m_globalAlpha(1)
103     , m_globalComposite(CompositeSourceOver)
104     , m_appliedStrokePattern(false)
105     , m_appliedFillPattern(false)
106 {
107 }
108
109 void CanvasRenderingContext2D::save()
110 {
111     ASSERT(m_stateStack.size() >= 1);
112     m_stateStack.append(state());
113     GraphicsContext* c = drawingContext();
114     if (!c)
115         return;
116     c->save();
117 }
118
119 void CanvasRenderingContext2D::restore()
120 {
121     ASSERT(m_stateStack.size() >= 1);
122     if (m_stateStack.size() <= 1)
123         return;
124     m_path.transform(state().m_transform);
125     m_stateStack.removeLast();
126     m_path.transform(state().m_transform.inverse());
127     GraphicsContext* c = drawingContext();
128     if (!c)
129         return;
130     c->restore();
131 }
132
133 CanvasStyle* CanvasRenderingContext2D::strokeStyle() const
134 {
135     return state().m_strokeStyle.get();
136 }
137
138 void CanvasRenderingContext2D::setStrokeStyle(PassRefPtr<CanvasStyle> style)
139 {
140     if (!style)
141         return;
142
143     if (m_canvas->originClean()) {
144         if (CanvasPattern* pattern = style->pattern()) {
145             if (!pattern->originClean())
146                 m_canvas->setOriginTainted();
147         }
148     }
149
150     state().m_strokeStyle = style;
151     GraphicsContext* c = drawingContext();
152     if (!c)
153         return;
154     state().m_strokeStyle->applyStrokeColor(c);
155     state().m_appliedStrokePattern = false;
156 }
157
158 CanvasStyle* CanvasRenderingContext2D::fillStyle() const
159 {
160     return state().m_fillStyle.get();
161 }
162
163 void CanvasRenderingContext2D::setFillStyle(PassRefPtr<CanvasStyle> style)
164 {
165     if (!style)
166         return;
167  
168     if (m_canvas->originClean()) {
169         if (CanvasPattern* pattern = style->pattern()) {
170             if (!pattern->originClean())
171                 m_canvas->setOriginTainted();
172         }
173     }
174
175     state().m_fillStyle = style;
176     GraphicsContext* c = drawingContext();
177     if (!c)
178         return;
179 #if PLATFORM(CAIRO)
180     // FIXME: hack to reduce code duplication in CanvasStyle.cpp
181     state().m_fillStyle->applyStrokeColor(c);
182 #else
183     state().m_fillStyle->applyFillColor(c);
184 #endif
185     state().m_appliedFillPattern = false;
186 }
187
188 float CanvasRenderingContext2D::lineWidth() const
189 {
190     return state().m_lineWidth;
191 }
192
193 void CanvasRenderingContext2D::setLineWidth(float width)
194 {
195     if (!(width > 0))
196         return;
197     state().m_lineWidth = width;
198     GraphicsContext* c = drawingContext();
199     if (!c)
200         return;
201     c->setStrokeThickness(width);
202 }
203
204 String CanvasRenderingContext2D::lineCap() const
205 {
206     return lineCapName(state().m_lineCap);
207 }
208
209 void CanvasRenderingContext2D::setLineCap(const String& s)
210 {
211     LineCap cap;
212     if (!parseLineCap(s, cap))
213         return;
214     state().m_lineCap = cap;
215     GraphicsContext* c = drawingContext();
216     if (!c)
217         return;
218     c->setLineCap(cap);
219 }
220
221 String CanvasRenderingContext2D::lineJoin() const
222 {
223     return lineJoinName(state().m_lineJoin);
224 }
225
226 void CanvasRenderingContext2D::setLineJoin(const String& s)
227 {
228     LineJoin join;
229     if (!parseLineJoin(s, join))
230         return;
231     state().m_lineJoin = join;
232     GraphicsContext* c = drawingContext();
233     if (!c)
234         return;
235     c->setLineJoin(join);
236 }
237
238 float CanvasRenderingContext2D::miterLimit() const
239 {
240     return state().m_miterLimit;
241 }
242
243 void CanvasRenderingContext2D::setMiterLimit(float limit)
244 {
245     if (!(limit > 0))
246         return;
247     state().m_miterLimit = limit;
248     GraphicsContext* c = drawingContext();
249     if (!c)
250         return;
251     c->setMiterLimit(limit);
252 }
253
254 float CanvasRenderingContext2D::shadowOffsetX() const
255 {
256     return state().m_shadowOffset.width();
257 }
258
259 void CanvasRenderingContext2D::setShadowOffsetX(float x)
260 {
261     state().m_shadowOffset.setWidth(x);
262     applyShadow();
263 }
264
265 float CanvasRenderingContext2D::shadowOffsetY() const
266 {
267     return state().m_shadowOffset.height();
268 }
269
270 void CanvasRenderingContext2D::setShadowOffsetY(float y)
271 {
272     state().m_shadowOffset.setHeight(y);
273     applyShadow();
274 }
275
276 float CanvasRenderingContext2D::shadowBlur() const
277 {
278     return state().m_shadowBlur;
279 }
280
281 void CanvasRenderingContext2D::setShadowBlur(float blur)
282 {
283     state().m_shadowBlur = blur;
284     applyShadow();
285 }
286
287 String CanvasRenderingContext2D::shadowColor() const
288 {
289     // FIXME: What should this return if you called setShadow with a non-string color?
290     return state().m_shadowColor;
291 }
292
293 void CanvasRenderingContext2D::setShadowColor(const String& color)
294 {
295     state().m_shadowColor = color;
296     applyShadow();
297 }
298
299 float CanvasRenderingContext2D::globalAlpha() const
300 {
301     return state().m_globalAlpha;
302 }
303
304 void CanvasRenderingContext2D::setGlobalAlpha(float alpha)
305 {
306     if (!(alpha >= 0 && alpha <= 1))
307         return;
308     state().m_globalAlpha = alpha;
309     GraphicsContext* c = drawingContext();
310     if (!c)
311         return;
312     c->setAlpha(alpha);
313 }
314
315 String CanvasRenderingContext2D::globalCompositeOperation() const
316 {
317     return compositeOperatorName(state().m_globalComposite);
318 }
319
320 void CanvasRenderingContext2D::setGlobalCompositeOperation(const String& operation)
321 {
322     CompositeOperator op;
323     if (!parseCompositeOperator(operation, op))
324         return;
325     state().m_globalComposite = op;
326     GraphicsContext* c = drawingContext();
327     if (!c)
328         return;
329     c->setCompositeOperation(op);
330 }
331
332 void CanvasRenderingContext2D::scale(float sx, float sy)
333 {
334     GraphicsContext* c = drawingContext();
335     if (!c)
336         return;
337     c->scale(FloatSize(sx, sy));
338     state().m_transform.scale(sx, sy);
339     m_path.transform(AffineTransform().scale(1.0/sx, 1.0/sy));
340 }
341
342 void CanvasRenderingContext2D::rotate(float angleInRadians)
343 {
344     GraphicsContext* c = drawingContext();
345     if (!c)
346         return;
347     c->rotate(angleInRadians);
348     state().m_transform.rotate(angleInRadians / piDouble * 180.0);
349     m_path.transform(AffineTransform().rotate(-angleInRadians / piDouble * 180.0));
350 }
351
352 void CanvasRenderingContext2D::translate(float tx, float ty)
353 {
354     GraphicsContext* c = drawingContext();
355     if (!c)
356         return;
357     c->translate(tx, ty);
358     state().m_transform.translate(tx, ty);
359     m_path.transform(AffineTransform().translate(-tx, -ty));
360 }
361
362 void CanvasRenderingContext2D::transform(float m11, float m12, float m21, float m22, float dx, float dy)
363 {
364     GraphicsContext* c = drawingContext();
365     if (!c)
366         return;
367     
368     // HTML5 3.14.11.1 -- ignore any calls that pass non-finite numbers
369     if (!isfinite(m11) | !isfinite(m21) | !isfinite(dx) | 
370         !isfinite(m12) | !isfinite(m22) | !isfinite(dy))
371         return;
372     AffineTransform transform(m11, m12, m21, m22, dx, dy);
373     c->concatCTM(transform);
374     state().m_transform.multiply(transform);
375     m_path.transform(transform.inverse());
376 }
377
378 void CanvasRenderingContext2D::setStrokeColor(const String& color)
379 {
380     setStrokeStyle(CanvasStyle::create(color));
381 }
382
383 void CanvasRenderingContext2D::setStrokeColor(float grayLevel)
384 {
385     setStrokeStyle(CanvasStyle::create(grayLevel, 1));
386 }
387
388 void CanvasRenderingContext2D::setStrokeColor(const String& color, float alpha)
389 {
390     setStrokeStyle(CanvasStyle::create(color, alpha));
391 }
392
393 void CanvasRenderingContext2D::setStrokeColor(float grayLevel, float alpha)
394 {
395     setStrokeStyle(CanvasStyle::create(grayLevel, alpha));
396 }
397
398 void CanvasRenderingContext2D::setStrokeColor(float r, float g, float b, float a)
399 {
400     setStrokeStyle(CanvasStyle::create(r, g, b, a));
401 }
402
403 void CanvasRenderingContext2D::setStrokeColor(float c, float m, float y, float k, float a)
404 {
405     setStrokeStyle(CanvasStyle::create(c, m, y, k, a));
406 }
407
408 void CanvasRenderingContext2D::setFillColor(const String& color)
409 {
410     setFillStyle(CanvasStyle::create(color));
411 }
412
413 void CanvasRenderingContext2D::setFillColor(float grayLevel)
414 {
415     setFillStyle(CanvasStyle::create(grayLevel, 1));
416 }
417
418 void CanvasRenderingContext2D::setFillColor(const String& color, float alpha)
419 {
420     setFillStyle(CanvasStyle::create(color, 1));
421 }
422
423 void CanvasRenderingContext2D::setFillColor(float grayLevel, float alpha)
424 {
425     setFillStyle(CanvasStyle::create(grayLevel, alpha));
426 }
427
428 void CanvasRenderingContext2D::setFillColor(float r, float g, float b, float a)
429 {
430     setFillStyle(CanvasStyle::create(r, g, b, a));
431 }
432
433 void CanvasRenderingContext2D::setFillColor(float c, float m, float y, float k, float a)
434 {
435     setFillStyle(CanvasStyle::create(c, m, y, k, a));
436 }
437
438 void CanvasRenderingContext2D::beginPath()
439 {
440     m_path.clear();
441 }
442
443 void CanvasRenderingContext2D::closePath()
444 {
445     m_path.closeSubpath();
446 }
447
448 void CanvasRenderingContext2D::moveTo(float x, float y)
449 {
450     if (!isfinite(x) | !isfinite(y))
451         return;
452     m_path.moveTo(FloatPoint(x, y));
453 }
454
455 void CanvasRenderingContext2D::lineTo(float x, float y)
456 {
457     if (!isfinite(x) | !isfinite(y))
458         return;
459     m_path.addLineTo(FloatPoint(x, y));
460 }
461
462 void CanvasRenderingContext2D::quadraticCurveTo(float cpx, float cpy, float x, float y)
463 {
464     if (!isfinite(cpx) | !isfinite(cpy) | !isfinite(x) | !isfinite(y))
465         return;
466     m_path.addQuadCurveTo(FloatPoint(cpx, cpy), FloatPoint(x, y));
467 }
468
469 void CanvasRenderingContext2D::bezierCurveTo(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y)
470 {
471     if (!isfinite(cp1x) | !isfinite(cp1y) | !isfinite(cp2x) | !isfinite(cp2y) | !isfinite(x) | !isfinite(y))
472         return;
473     m_path.addBezierCurveTo(FloatPoint(cp1x, cp1y), FloatPoint(cp2x, cp2y), FloatPoint(x, y));
474 }
475
476 void CanvasRenderingContext2D::arcTo(float x0, float y0, float x1, float y1, float r, ExceptionCode& ec)
477 {
478     ec = 0;
479     if (!isfinite(x0) | !isfinite(y0) | !isfinite(x1) | !isfinite(y1) | !isfinite(r))
480         return;
481     
482     if (r < 0) {
483         ec = INDEX_SIZE_ERR;
484         return;
485     }
486     
487     m_path.addArcTo(FloatPoint(x0, y0), FloatPoint(x1, y1), r);
488 }
489
490 void CanvasRenderingContext2D::arc(float x, float y, float r, float sa, float ea, bool anticlockwise, ExceptionCode& ec)
491 {
492     ec = 0;
493     if (!isfinite(x) | !isfinite(y) | !isfinite(r) | !isfinite(sa) | !isfinite(ea))
494         return;
495     
496     if (r < 0) {
497         ec = INDEX_SIZE_ERR;
498         return;
499     }
500     
501     m_path.addArc(FloatPoint(x, y), r, sa, ea, anticlockwise);
502 }
503     
504 static bool validateRectForCanvas(float& x, float& y, float& width, float& height)
505 {
506     if (!isfinite(x) | !isfinite(y) | !isfinite(width) | !isfinite(height))
507         return false;
508     
509     if (width < 0) {
510         width = -width;
511         x -= width;
512     }
513     
514     if (height < 0) {
515         height = -height;
516         y -= height;
517     }
518     
519     return true;
520 }
521
522 void CanvasRenderingContext2D::rect(float x, float y, float width, float height)
523 {
524     if (!validateRectForCanvas(x, y, width, height))
525         return;
526         
527     m_path.addRect(FloatRect(x, y, width, height));
528 }
529
530 #if ENABLE(DASHBOARD_SUPPORT)
531 void CanvasRenderingContext2D::clearPathForDashboardBackwardCompatibilityMode()
532 {
533     if (Settings* settings = m_canvas->document()->settings())
534         if (settings->usesDashboardBackwardCompatibilityMode())
535             m_path.clear();
536 }
537 #endif
538
539 void CanvasRenderingContext2D::fill()
540 {
541     GraphicsContext* c = drawingContext();
542     if (!c)
543         return;
544
545     c->beginPath();
546     c->addPath(m_path);
547     if (!m_path.isEmpty())
548         willDraw(m_path.boundingRect());
549
550 #if PLATFORM(CG)
551     if (state().m_fillStyle->canvasGradient()) {
552         // Shading works on the entire clip region, so convert the current path to a clip.
553         c->save();
554         CGContextClip(c->platformContext());
555         CGContextDrawShading(c->platformContext(), state().m_fillStyle->canvasGradient()->gradient().platformGradient());        
556         c->restore();
557     } else {
558         if (state().m_fillStyle->pattern())
559             applyFillPattern();
560         CGContextFillPath(c->platformContext());
561     }
562 #elif PLATFORM(QT)
563     QPainterPath* path = m_path.platformPath();
564     QPainter* p = static_cast<QPainter*>(c->platformContext());
565     if (state().m_fillStyle->canvasGradient()) {
566         p->fillPath(*path, QBrush(*(state().m_fillStyle->canvasGradient()->gradient().platformGradient())));
567     } else {
568         if (state().m_fillStyle->pattern())
569             applyFillPattern();
570         p->fillPath(*path, p->brush());
571     }
572 #elif PLATFORM(CAIRO)
573     cairo_t* cr = c->platformContext();
574     cairo_save(cr);
575
576     if (state().m_fillStyle->canvasGradient()) {
577         cairo_set_source(cr, state().m_fillStyle->canvasGradient()->gradient().platformGradient());
578         cairo_fill(cr);
579     } else {
580         if (state().m_fillStyle->pattern())
581             applyFillPattern();
582         cairo_fill(cr);
583     }
584     cairo_restore(cr);
585 #endif
586
587 #if ENABLE(DASHBOARD_SUPPORT)
588     clearPathForDashboardBackwardCompatibilityMode();
589 #endif
590 }
591
592 void CanvasRenderingContext2D::stroke()
593 {
594     GraphicsContext* c = drawingContext();
595     if (!c)
596         return;
597     c->beginPath();
598     c->addPath(m_path);
599
600     if (!m_path.isEmpty()) {
601         // FIXME: This is insufficient, need to use CGContextReplacePathWithStrokedPath to expand to required bounds
602         float lineWidth = state().m_lineWidth;
603         float inset = lineWidth / 2;
604         FloatRect boundingRect = m_path.boundingRect();
605         boundingRect.inflate(inset);
606         willDraw(boundingRect);
607     }
608     
609     // FIXME: Do this through platform-independent GraphicsContext API.
610 #if PLATFORM(CG)
611     if (state().m_strokeStyle->canvasGradient()) {
612         // Shading works on the entire clip region, so convert the current path to a clip.
613         c->save();
614         CGContextReplacePathWithStrokedPath(c->platformContext());
615         CGContextClip(c->platformContext());
616         CGContextDrawShading(c->platformContext(), state().m_strokeStyle->canvasGradient()->gradient().platformGradient());        
617         c->restore();
618     } else {
619         if (state().m_strokeStyle->pattern())
620             applyStrokePattern();
621         CGContextStrokePath(c->platformContext());
622     }
623 #elif PLATFORM(QT)
624     QPainterPath* path = m_path.platformPath();
625     QPainter* p = static_cast<QPainter*>(c->platformContext());
626     if (state().m_strokeStyle->canvasGradient()) {
627         p->save();
628         p->setBrush(*(state().m_strokeStyle->canvasGradient()->gradient().platformGradient()));
629         p->strokePath(*path, p->pen());
630         p->restore();
631     } else {
632         if (state().m_strokeStyle->pattern())
633             applyStrokePattern();
634         p->strokePath(*path, p->pen());
635     }
636 #elif PLATFORM(CAIRO)
637     cairo_t* cr = c->platformContext();
638     cairo_save(cr);
639     if (state().m_strokeStyle->canvasGradient()) {
640         cairo_set_source(cr, state().m_strokeStyle->canvasGradient()->gradient().platformGradient());
641         c->addPath(m_path);
642         cairo_stroke(cr);
643     } else {
644         if (state().m_strokeStyle->pattern())
645             applyStrokePattern();
646         c->addPath(m_path);
647         cairo_stroke(cr);
648     }
649     cairo_restore(cr);
650 #endif
651
652 #if ENABLE(DASHBOARD_SUPPORT)
653     clearPathForDashboardBackwardCompatibilityMode();
654 #endif
655 }
656
657 void CanvasRenderingContext2D::clip()
658 {
659     GraphicsContext* c = drawingContext();
660     if (!c)
661         return;
662     c->clip(m_path);
663 #if ENABLE(DASHBOARD_SUPPORT)
664     clearPathForDashboardBackwardCompatibilityMode();
665 #endif
666 }
667
668 bool CanvasRenderingContext2D::isPointInPath(const float x, const float y)
669 {
670     GraphicsContext* c = drawingContext();
671     if (!c)
672         return false;
673     FloatPoint point(x, y);
674     // We have to invert the current transform to ensure we correctly handle the
675     // transforms applied to the current path.
676     AffineTransform ctm = state().m_transform;
677     if (!ctm.isInvertible())
678         return false;
679     FloatPoint transformedPoint = ctm.inverse().mapPoint(point);
680     return m_path.contains(transformedPoint);
681 }
682
683 void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height)
684 {
685     if (!validateRectForCanvas(x, y, width, height))
686         return;
687     GraphicsContext* c = drawingContext();
688     if (!c)
689         return;
690     FloatRect rect(x, y, width, height);
691     willDraw(rect);
692     c->clearRect(rect);
693 }
694
695 void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height)
696 {
697     if (!validateRectForCanvas(x, y, width, height))
698         return;
699
700     GraphicsContext* c = drawingContext();
701     if (!c)
702         return;
703
704     FloatRect rect(x, y, width, height);
705     willDraw(rect);
706
707     // FIXME: Do this through platform-independent GraphicsContext API.
708 #if PLATFORM(CG)
709     if (state().m_fillStyle->canvasGradient()) {
710         // Shading works on the entire clip region, so convert the rect to a clip.
711         c->save();
712         CGContextClipToRect(c->platformContext(), rect);
713         CGContextDrawShading(c->platformContext(), state().m_fillStyle->canvasGradient()->gradient().platformGradient());        
714         c->restore();
715     } else {
716         if (state().m_fillStyle->pattern())
717             applyFillPattern();
718         CGContextFillRect(c->platformContext(), rect);
719     }
720 #elif PLATFORM(QT)
721     QPainter* p = static_cast<QPainter*>(c->platformContext());
722     if (state().m_fillStyle->canvasGradient()) {
723         p->fillRect(rect, QBrush(*(state().m_fillStyle->canvasGradient()->gradient().platformGradient())));
724     } else {
725         if (state().m_fillStyle->pattern())
726             applyFillPattern();
727         p->fillRect(rect, p->brush());
728     }
729 #elif PLATFORM(CAIRO)
730     cairo_t* cr = c->platformContext();
731     cairo_save(cr);
732     if (state().m_fillStyle->canvasGradient()) {
733         cairo_set_source(cr, state().m_fillStyle->canvasGradient()->gradient().platformGradient());
734     } else {
735         if (state().m_fillStyle->pattern())
736             applyFillPattern();
737     }
738     cairo_rectangle(cr, x, y, width, height);
739     cairo_fill(cr);
740     cairo_restore(cr);
741 #endif
742 }
743
744 void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height)
745 {
746     if (!validateRectForCanvas(x, y, width, height))
747         return;
748     strokeRect(x, y, width, height, state().m_lineWidth);
749 }
750
751 void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height, float lineWidth)
752 {
753     if (!validateRectForCanvas(x, y, width, height))
754         return;
755     
756     if (!(lineWidth >= 0))
757         return;
758
759     GraphicsContext* c = drawingContext();
760     if (!c)
761         return;
762
763     FloatRect rect(x, y, width, height);
764
765     FloatRect boundingRect = rect;
766     boundingRect.inflate(lineWidth / 2);
767     willDraw(boundingRect);
768
769     // FIXME: No support for gradients!
770     if (state().m_strokeStyle->pattern())
771         applyStrokePattern();
772
773     c->strokeRect(rect, lineWidth);
774 }
775
776 #if PLATFORM(CG)
777 static inline CGSize adjustedShadowSize(CGFloat width, CGFloat height)
778 {
779     // Work around <rdar://problem/5539388> by ensuring that shadow offsets will get truncated
780     // to the desired integer.
781     static const CGFloat extraShadowOffset = narrowPrecisionToCGFloat(1.0 / 128);
782     if (width > 0)
783         width += extraShadowOffset;
784     else if (width < 0)
785         width -= extraShadowOffset;
786
787     if (height > 0)
788         height += extraShadowOffset;
789     else if (height < 0)
790         height -= extraShadowOffset;
791
792     return CGSizeMake(width, height);
793 }
794 #endif
795
796 void CanvasRenderingContext2D::setShadow(float width, float height, float blur)
797 {
798     state().m_shadowOffset = FloatSize(width, height);
799     state().m_shadowBlur = blur;
800     state().m_shadowColor = "";
801     applyShadow();
802 }
803
804 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& color)
805 {
806     state().m_shadowOffset = FloatSize(width, height);
807     state().m_shadowBlur = blur;
808     state().m_shadowColor = color;
809     applyShadow();
810 }
811
812 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel)
813 {
814     state().m_shadowOffset = FloatSize(width, height);
815     state().m_shadowBlur = blur;
816     state().m_shadowColor = "";
817
818     GraphicsContext* c = drawingContext();
819     if (!c)
820         return;
821     // FIXME: Do this through platform-independent GraphicsContext API.
822 #if PLATFORM(CG)
823     const CGFloat components[2] = { grayLevel, 1 };
824     CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceGray();
825     CGColorRef color = CGColorCreate(colorSpace, components);
826     CGColorSpaceRelease(colorSpace);
827     CGContextSetShadowWithColor(c->platformContext(), adjustedShadowSize(width, -height), blur, color);
828     CGColorRelease(color);
829 #endif
830 }
831
832 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& color, float alpha)
833 {
834     state().m_shadowOffset = FloatSize(width, height);
835     state().m_shadowBlur = blur;
836     state().m_shadowColor = color;
837
838     GraphicsContext* c = drawingContext();
839     if (!c)
840         return;
841     // FIXME: Do this through platform-independent GraphicsContext API.
842 #if PLATFORM(CG)
843     RGBA32 rgba = 0; // default is transparent black
844     CSSParser::parseColor(rgba, color);
845     const CGFloat components[4] = {
846         ((rgba >> 16) & 0xFF) / 255.0f,
847         ((rgba >> 8) & 0xFF) / 255.0f,
848         (rgba & 0xFF) / 255.0f,
849         alpha
850     };
851     CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
852     CGColorRef shadowColor = CGColorCreate(colorSpace, components);
853     CGColorSpaceRelease(colorSpace);
854     CGContextSetShadowWithColor(c->platformContext(), adjustedShadowSize(width, -height), blur, shadowColor);
855     CGColorRelease(shadowColor);
856 #endif
857 }
858
859 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel, float alpha)
860 {
861     state().m_shadowOffset = FloatSize(width, height);
862     state().m_shadowBlur = blur;
863     state().m_shadowColor = "";
864
865     GraphicsContext* c = drawingContext();
866     if (!c)
867         return;
868     // FIXME: Do this through platform-independent GraphicsContext API.
869 #if PLATFORM(CG)
870     const CGFloat components[2] = { grayLevel, alpha };
871     CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceGray();
872     CGColorRef color = CGColorCreate(colorSpace, components);
873     CGColorSpaceRelease(colorSpace);
874     CGContextSetShadowWithColor(c->platformContext(), adjustedShadowSize(width, -height), blur, color);
875     CGColorRelease(color);
876 #endif
877 }
878
879 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float r, float g, float b, float a)
880 {
881     state().m_shadowOffset = FloatSize(width, height);
882     state().m_shadowBlur = blur;
883     state().m_shadowColor = "";
884
885     GraphicsContext* c = drawingContext();
886     if (!c)
887         return;
888     // FIXME: Do this through platform-independent GraphicsContext API.
889 #if PLATFORM(CG)
890     const CGFloat components[4] = { r, g, b, a };
891     CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
892     CGColorRef shadowColor = CGColorCreate(colorSpace, components);
893     CGColorSpaceRelease(colorSpace);
894     CGContextSetShadowWithColor(c->platformContext(), adjustedShadowSize(width, -height), blur, shadowColor);
895     CGColorRelease(shadowColor);
896 #endif
897 }
898
899 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float c, float m, float y, float k, float a)
900 {
901     state().m_shadowOffset = FloatSize(width, height);
902     state().m_shadowBlur = blur;
903     state().m_shadowColor = "";
904
905     GraphicsContext* dc = drawingContext();
906     if (!dc)
907         return;
908     // FIXME: Do this through platform-independent GraphicsContext API.
909 #if PLATFORM(CG)
910     const CGFloat components[5] = { c, m, y, k, a };
911     CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceCMYK();
912     CGColorRef shadowColor = CGColorCreate(colorSpace, components);
913     CGColorSpaceRelease(colorSpace);
914     CGContextSetShadowWithColor(dc->platformContext(), adjustedShadowSize(width, -height), blur, shadowColor);
915     CGColorRelease(shadowColor);
916 #endif
917 }
918
919 void CanvasRenderingContext2D::clearShadow()
920 {
921     state().m_shadowOffset = FloatSize();
922     state().m_shadowBlur = 0;
923     state().m_shadowColor = "";
924     applyShadow();
925 }
926
927 void CanvasRenderingContext2D::applyShadow()
928 {
929     GraphicsContext* c = drawingContext();
930     if (!c)
931         return;
932     // FIXME: Do this through platform-independent GraphicsContext API.
933 #if PLATFORM(CG)
934     RGBA32 rgba = 0; // default is transparent black
935     if (!state().m_shadowColor.isEmpty())
936         CSSParser::parseColor(rgba, state().m_shadowColor);
937     const CGFloat components[4] = {
938         ((rgba >> 16) & 0xFF) / 255.0f,
939         ((rgba >> 8) & 0xFF) / 255.0f,
940         (rgba & 0xFF) / 255.0f,
941         ((rgba >> 24) & 0xFF) / 255.0f
942     };
943     CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
944     CGColorRef color = CGColorCreate(colorSpace, components);
945     CGColorSpaceRelease(colorSpace);
946
947     CGContextSetShadowWithColor(c->platformContext(), adjustedShadowSize(state().m_shadowOffset.width(), -state().m_shadowOffset.height()), state().m_shadowBlur, color);
948     CGColorRelease(color);
949 #endif
950 }
951
952 static IntSize size(HTMLImageElement* image)
953 {
954     if (CachedImage* cachedImage = image->cachedImage())
955         return cachedImage->imageSize(1.0f); // FIXME: Not sure about this.
956     return IntSize();
957 }
958
959 void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, float x, float y)
960 {
961     ASSERT(image);
962     IntSize s = size(image);
963     ExceptionCode ec;
964     drawImage(image, x, y, s.width(), s.height(), ec);
965 }
966
967 void CanvasRenderingContext2D::drawImage(HTMLImageElement* image,
968     float x, float y, float width, float height, ExceptionCode& ec)
969 {
970     ASSERT(image);
971     IntSize s = size(image);
972     drawImage(image, FloatRect(0, 0, s.width(), s.height()), FloatRect(x, y, width, height), ec);
973 }
974
975 void CanvasRenderingContext2D::checkOrigin(const KURL& url)
976 {
977     RefPtr<SecurityOrigin> origin = SecurityOrigin::create(url);
978     if (!m_canvas->document()->securityOrigin()->canAccess(origin.get()))
979         m_canvas->setOriginTainted();
980 }
981
982 void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, const FloatRect& srcRect, const FloatRect& dstRect,
983     ExceptionCode& ec)
984 {
985     ASSERT(image);
986
987     ec = 0;
988
989     FloatRect imageRect = FloatRect(FloatPoint(), size(image));
990     if (!(imageRect.contains(srcRect) && srcRect.width() >= 0 && srcRect.height() >= 0 
991             && dstRect.width() >= 0 && dstRect.height() >= 0)) {
992         ec = INDEX_SIZE_ERR;
993         return;
994     }
995
996     if (srcRect.isEmpty() || dstRect.isEmpty())
997         return;
998
999     GraphicsContext* c = drawingContext();
1000     if (!c)
1001         return;
1002
1003     CachedImage* cachedImage = image->cachedImage();
1004     if (!cachedImage)
1005         return;
1006
1007     if (m_canvas->originClean())
1008         checkOrigin(KURL(cachedImage->url()));
1009
1010     FloatRect sourceRect = c->roundToDevicePixels(srcRect);
1011     FloatRect destRect = c->roundToDevicePixels(dstRect);
1012     willDraw(destRect);
1013     c->drawImage(cachedImage->image(), destRect, sourceRect, state().m_globalComposite);
1014 }
1015
1016 void CanvasRenderingContext2D::drawImage(HTMLCanvasElement* canvas, float x, float y)
1017 {
1018     ASSERT(canvas);
1019     ExceptionCode ec;
1020     drawImage(canvas, x, y, canvas->width(), canvas->height(), ec);
1021 }
1022
1023 void CanvasRenderingContext2D::drawImage(HTMLCanvasElement* canvas,
1024     float x, float y, float width, float height, ExceptionCode& ec)
1025 {
1026     ASSERT(canvas);
1027     drawImage(canvas, FloatRect(0, 0, canvas->width(), canvas->height()), FloatRect(x, y, width, height), ec);
1028 }
1029
1030 void CanvasRenderingContext2D::drawImage(HTMLCanvasElement* canvas, const FloatRect& srcRect,
1031     const FloatRect& dstRect, ExceptionCode& ec)
1032 {
1033     ASSERT(canvas);
1034
1035     ec = 0;
1036
1037     FloatRect srcCanvasRect = FloatRect(FloatPoint(), canvas->size());
1038     if (!(srcCanvasRect.contains(srcRect) && srcRect.width() >= 0 && srcRect.height() >= 0 
1039             && dstRect.width() >= 0 && dstRect.height() >= 0)) {
1040         ec = INDEX_SIZE_ERR;
1041         return;
1042     }
1043
1044     if (srcRect.isEmpty() || dstRect.isEmpty())
1045         return;
1046
1047     GraphicsContext* c = drawingContext();
1048     if (!c)
1049         return;
1050         
1051     FloatRect sourceRect = c->roundToDevicePixels(srcRect);
1052     FloatRect destRect = c->roundToDevicePixels(dstRect);
1053         
1054     // FIXME: Do this through platform-independent GraphicsContext API.
1055     ImageBuffer* buffer = canvas->buffer();
1056     if (!buffer)
1057         return;
1058
1059     if (!canvas->originClean())
1060         m_canvas->setOriginTainted();
1061
1062     c->drawImage(buffer->image(), destRect, sourceRect);
1063     willDraw(destRect); // This call comes after drawImage, since the buffer we draw into may be our own, and we need to make sure it is dirty.
1064                         // FIXME: Arguably willDraw should become didDraw and occur after drawing calls and not before them to avoid problems like this.
1065 }
1066
1067 // FIXME: Why isn't this just another overload of drawImage? Why have a different name?
1068 void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image,
1069     float sx, float sy, float sw, float sh,
1070     float dx, float dy, float dw, float dh,
1071     const String& compositeOperation)
1072 {
1073     if (!image)
1074         return;
1075
1076     CachedImage* cachedImage = image->cachedImage();
1077     if (!cachedImage)
1078         return;
1079
1080     if (m_canvas->originClean())
1081         checkOrigin(KURL(cachedImage->url()));
1082
1083     GraphicsContext* c = drawingContext();
1084     if (!c)
1085         return;
1086
1087     CompositeOperator op;
1088     if (!parseCompositeOperator(compositeOperation, op))
1089         op = CompositeSourceOver;
1090
1091     FloatRect destRect = FloatRect(dx, dy, dw, dh);
1092     willDraw(destRect);
1093     c->drawImage(cachedImage->image(), destRect, FloatRect(sx, sy, sw, sh), op);
1094 }
1095
1096 void CanvasRenderingContext2D::setAlpha(float alpha)
1097 {
1098     setGlobalAlpha(alpha);
1099 }
1100
1101 void CanvasRenderingContext2D::setCompositeOperation(const String& operation)
1102 {
1103     setGlobalCompositeOperation(operation);
1104 }
1105
1106 PassRefPtr<CanvasGradient> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)
1107 {
1108     return CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));
1109 }
1110
1111 PassRefPtr<CanvasGradient> CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1)
1112 {
1113     return CanvasGradient::create(FloatPoint(x0, y0), r0, FloatPoint(x1, y1), r1);
1114 }
1115
1116 PassRefPtr<CanvasPattern> CanvasRenderingContext2D::createPattern(HTMLImageElement* image,
1117     const String& repetitionType, ExceptionCode& ec)
1118 {
1119     bool repeatX, repeatY;
1120     ec = 0;
1121     CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY, ec);
1122     if (ec)
1123         return 0;
1124     
1125     bool originClean = true;
1126     if (CachedImage* cachedImage = image->cachedImage()) {
1127         KURL url(cachedImage->url());
1128         RefPtr<SecurityOrigin> origin = SecurityOrigin::create(url);
1129         originClean = m_canvas->document()->securityOrigin()->canAccess(origin.get());
1130     }
1131     return CanvasPattern::create(image->cachedImage(), repeatX, repeatY, originClean);
1132 }
1133
1134 PassRefPtr<CanvasPattern> CanvasRenderingContext2D::createPattern(HTMLCanvasElement* canvas,
1135     const String& repetitionType, ExceptionCode& ec)
1136 {
1137     bool repeatX, repeatY;
1138     ec = 0;
1139     CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY, ec);
1140     if (ec)
1141         return 0;
1142     // FIXME: Do this through platform-independent GraphicsContext API.
1143 #if PLATFORM(CG)
1144     RetainPtr<CGImageRef> image(AdoptCF, canvas->createPlatformImage());
1145     if (!image)
1146         return 0;
1147     return CanvasPattern::create(image.get(), repeatX, repeatY, canvas->originClean());
1148 #elif PLATFORM(CAIRO)
1149     cairo_surface_t* surface = canvas->createPlatformImage();
1150     if (!surface)
1151         return 0;
1152     RefPtr<CanvasPattern> pattern = CanvasPattern::create(surface, repeatX, repeatY, canvas->originClean());
1153     cairo_surface_destroy(surface);
1154     return pattern.release();
1155 #else
1156     notImplemented();
1157     return 0;
1158 #endif
1159 }
1160
1161 void CanvasRenderingContext2D::willDraw(const FloatRect& r)
1162 {
1163     GraphicsContext* c = drawingContext();
1164     if (!c)
1165         return;
1166
1167     m_canvas->willDraw(c->getCTM().mapRect(r));
1168 }
1169
1170 GraphicsContext* CanvasRenderingContext2D::drawingContext() const
1171 {
1172     return m_canvas->drawingContext();
1173 }
1174
1175 void CanvasRenderingContext2D::applyStrokePattern()
1176 {
1177     GraphicsContext* c = drawingContext();
1178     if (!c)
1179         return;
1180
1181 #if PLATFORM(CG)
1182     // Check for case where the pattern is already set.
1183     CGAffineTransform m = CGContextGetCTM(c->platformContext());
1184     if (state().m_appliedStrokePattern
1185             && CGAffineTransformEqualToTransform(m, state().m_strokeStylePatternTransform))
1186         return;
1187
1188     CanvasPattern* pattern = state().m_strokeStyle->pattern();
1189     if (!pattern)
1190         return;
1191
1192     CGPatternRef platformPattern = pattern->createPattern(m);
1193     if (!platformPattern)
1194         return;
1195
1196     CGColorSpaceRef patternSpace = CGColorSpaceCreatePattern(0);
1197     CGContextSetStrokeColorSpace(c->platformContext(), patternSpace);
1198     CGColorSpaceRelease(patternSpace);
1199
1200     const CGFloat patternAlpha = 1;
1201     CGContextSetStrokePattern(c->platformContext(), platformPattern, &patternAlpha);
1202     CGPatternRelease(platformPattern);
1203
1204     state().m_strokeStylePatternTransform = m;
1205 #elif PLATFORM(QT)
1206     notImplemented();
1207 #elif PLATFORM(CAIRO)
1208     CanvasPattern* pattern = state().m_strokeStyle->pattern();
1209     if (!pattern)
1210         return;
1211
1212     cairo_t* cr = c->platformContext();
1213     cairo_matrix_t m;
1214     cairo_get_matrix(cr, &m);
1215
1216     cairo_pattern_t* platformPattern = pattern->createPattern(m);
1217     if (!platformPattern)
1218         return;
1219
1220     cairo_set_source(cr, platformPattern);
1221     cairo_pattern_destroy(platformPattern);
1222 #endif
1223     state().m_appliedStrokePattern = true;
1224 }
1225
1226 void CanvasRenderingContext2D::applyFillPattern()
1227 {
1228     GraphicsContext* c = drawingContext();
1229     if (!c)
1230         return;
1231
1232 #if PLATFORM(CG)
1233     // Check for case where the pattern is already set.
1234     CGAffineTransform m = CGContextGetCTM(c->platformContext());
1235     if (state().m_appliedFillPattern
1236             && CGAffineTransformEqualToTransform(m, state().m_fillStylePatternTransform))
1237         return;
1238
1239     CanvasPattern* pattern = state().m_fillStyle->pattern();
1240     if (!pattern)
1241         return;
1242
1243     CGPatternRef platformPattern = pattern->createPattern(m);
1244     if (!platformPattern)
1245         return;
1246
1247     CGColorSpaceRef patternSpace = CGColorSpaceCreatePattern(0);
1248     CGContextSetFillColorSpace(c->platformContext(), patternSpace);
1249     CGColorSpaceRelease(patternSpace);
1250
1251     const CGFloat patternAlpha = 1;
1252     CGContextSetFillPattern(c->platformContext(), platformPattern, &patternAlpha);
1253     CGPatternRelease(platformPattern);
1254
1255     state().m_fillStylePatternTransform = m;
1256 #elif PLATFORM(QT)
1257     notImplemented();
1258 #elif PLATFORM(CAIRO)
1259     CanvasPattern* pattern = state().m_fillStyle->pattern();
1260     if (!pattern)
1261         return;
1262
1263     cairo_t* cr = c->platformContext();
1264     cairo_matrix_t m;
1265     cairo_get_matrix(cr, &m);
1266
1267     cairo_pattern_t* platformPattern = pattern->createPattern(m);
1268     if (!platformPattern)
1269         return;
1270
1271     cairo_set_source(cr, platformPattern);
1272     cairo_pattern_destroy(platformPattern);
1273 #endif
1274     state().m_appliedFillPattern = true;
1275 }
1276
1277 static PassRefPtr<ImageData> createEmptyImageData(const IntSize& size)
1278 {
1279     PassRefPtr<ImageData> data = ImageData::create(size.width(), size.height());
1280     memset(data->data()->data().data(), 0, data->data()->length());
1281     return data;
1282 }
1283
1284 PassRefPtr<ImageData> CanvasRenderingContext2D::createImageData(float sw, float sh) const
1285 {
1286     FloatSize unscaledSize(sw, sh);
1287     IntSize scaledSize = m_canvas->convertLogicalToDevice(unscaledSize);
1288     if (scaledSize.width() < 1)
1289         scaledSize.setWidth(1);
1290     if (scaledSize.height() < 1)
1291         scaledSize.setHeight(1);
1292     
1293     return createEmptyImageData(scaledSize);
1294 }
1295
1296 PassRefPtr<ImageData> CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh, ExceptionCode& ec) const
1297 {
1298     if (!m_canvas->originClean()) {
1299         ec = SECURITY_ERR;
1300         return 0;
1301     }
1302     
1303     FloatRect unscaledRect(sx, sy, sw, sh);
1304     IntRect scaledRect = m_canvas->convertLogicalToDevice(unscaledRect);
1305     if (scaledRect.width() < 1)
1306         scaledRect.setWidth(1);
1307     if (scaledRect.height() < 1)
1308         scaledRect.setHeight(1);
1309     ImageBuffer* buffer = m_canvas ? m_canvas->buffer() : 0;
1310     if (!buffer)
1311         return createEmptyImageData(scaledRect.size());
1312     return buffer->getImageData(scaledRect);
1313 }
1314
1315 void CanvasRenderingContext2D::putImageData(ImageData* data, float dx, float dy, ExceptionCode& ec)
1316 {
1317     if (!data) {
1318         ec = TYPE_MISMATCH_ERR;
1319         return;
1320     }
1321     putImageData(data, dx, dy, 0, 0, data->width(), data->height(), ec);
1322 }
1323
1324 void CanvasRenderingContext2D::putImageData(ImageData* data, float dx, float dy, float dirtyX, float dirtyY, 
1325                                             float dirtyWidth, float dirtyHeight, ExceptionCode& ec)
1326 {
1327     if (!data) {
1328         ec = TYPE_MISMATCH_ERR;
1329         return;
1330     }
1331     if (!isfinite(dx) || !isfinite(dy) || !isfinite(dirtyX) || 
1332         !isfinite(dirtyY) || !isfinite(dirtyWidth) || !isfinite(dirtyHeight)) {
1333         ec = INDEX_SIZE_ERR;
1334         return;
1335     }
1336
1337     ImageBuffer* buffer = m_canvas->buffer();
1338     if (!buffer)
1339         return;
1340
1341     if (dirtyWidth < 0) {
1342         dirtyX += dirtyWidth;
1343         dirtyWidth = -dirtyWidth;
1344     }
1345
1346     if (dirtyHeight < 0) {
1347         dirtyY += dirtyHeight;
1348         dirtyHeight = -dirtyHeight;
1349     }
1350
1351     FloatRect clipRect(dirtyX, dirtyY, dirtyWidth, dirtyHeight);
1352     clipRect.intersect(IntRect(0, 0, data->width(), data->height()));
1353     IntSize destOffset(static_cast<int>(dx), static_cast<int>(dy));
1354     IntRect sourceRect = enclosingIntRect(clipRect);
1355     sourceRect.move(destOffset);
1356     sourceRect.intersect(IntRect(IntPoint(), buffer->size()));
1357     if (sourceRect.isEmpty())
1358         return;
1359     willDraw(sourceRect);
1360     sourceRect.move(-destOffset);
1361     IntPoint destPoint(destOffset.width(), destOffset.height());
1362     
1363     buffer->putImageData(data, sourceRect, destPoint);
1364 }
1365
1366 } // namespace WebCore