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