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