Node::document() should return a reference.
[WebKit-https.git] / Source / WebCore / html / HTMLCanvasElement.cpp
1 /*
2  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
3  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
4  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
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 "HTMLCanvasElement.h"
30
31 #include "Attribute.h"
32 #include "CanvasContextAttributes.h"
33 #include "CanvasGradient.h"
34 #include "CanvasPattern.h"
35 #include "CanvasRenderingContext2D.h"
36 #include "Chrome.h"
37 #include "Document.h"
38 #include "ExceptionCode.h"
39 #include "Frame.h"
40 #include "GraphicsContext.h"
41 #include "HTMLNames.h"
42 #include "ImageBuffer.h"
43 #include "ImageData.h"
44 #include "MIMETypeRegistry.h"
45 #include "Page.h"
46 #include "RenderHTMLCanvas.h"
47 #include "ScriptController.h"
48 #include "Settings.h"
49 #include <math.h>
50
51 #include <runtime/JSLock.h>
52 #include <runtime/Operations.h>
53
54 #if ENABLE(WEBGL)    
55 #include "WebGLContextAttributes.h"
56 #include "WebGLRenderingContext.h"
57 #endif
58
59 namespace WebCore {
60
61 using namespace HTMLNames;
62
63 // These values come from the WhatWG spec.
64 static const int DefaultWidth = 300;
65 static const int DefaultHeight = 150;
66
67 // Firefox limits width/height to 32767 pixels, but slows down dramatically before it
68 // reaches that limit. We limit by area instead, giving us larger maximum dimensions,
69 // in exchange for a smaller maximum canvas size.
70 static const float MaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels
71
72 HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document* document)
73     : HTMLElement(tagName, document)
74     , m_size(DefaultWidth, DefaultHeight)
75     , m_rendererIsCanvas(false)
76     , m_ignoreReset(false)
77     , m_deviceScaleFactor(targetDeviceScaleFactor())
78     , m_originClean(true)
79     , m_hasCreatedImageBuffer(false)
80     , m_didClearImageBuffer(false)
81 {
82     ASSERT(hasTagName(canvasTag));
83     setHasCustomStyleResolveCallbacks();
84 }
85
86 PassRefPtr<HTMLCanvasElement> HTMLCanvasElement::create(Document* document)
87 {
88     return adoptRef(new HTMLCanvasElement(canvasTag, document));
89 }
90
91 PassRefPtr<HTMLCanvasElement> HTMLCanvasElement::create(const QualifiedName& tagName, Document* document)
92 {
93     return adoptRef(new HTMLCanvasElement(tagName, document));
94 }
95
96 HTMLCanvasElement::~HTMLCanvasElement()
97 {
98     HashSet<CanvasObserver*>::iterator end = m_observers.end();
99     for (HashSet<CanvasObserver*>::iterator it = m_observers.begin(); it != end; ++it)
100         (*it)->canvasDestroyed(this);
101
102     m_context.clear(); // Ensure this goes away before the ImageBuffer.
103 }
104
105 void HTMLCanvasElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
106 {
107     if (name == widthAttr || name == heightAttr)
108         reset();
109     HTMLElement::parseAttribute(name, value);
110 }
111
112 RenderObject* HTMLCanvasElement::createRenderer(RenderArena* arena, RenderStyle* style)
113 {
114     Frame* frame = document().frame();
115     if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript)) {
116         m_rendererIsCanvas = true;
117         return new (arena) RenderHTMLCanvas(this);
118     }
119
120     m_rendererIsCanvas = false;
121     return HTMLElement::createRenderer(arena, style);
122 }
123
124 void HTMLCanvasElement::willAttachRenderers()
125 {
126     setIsInCanvasSubtree(true);
127 }
128
129 bool HTMLCanvasElement::areAuthorShadowsAllowed() const
130 {
131     return false;
132 }
133
134 bool HTMLCanvasElement::canContainRangeEndPoint() const
135 {
136     return false;
137 }
138
139 bool HTMLCanvasElement::canStartSelection() const
140 {
141     return false;
142 }
143
144 void HTMLCanvasElement::addObserver(CanvasObserver* observer)
145 {
146     m_observers.add(observer);
147 }
148
149 void HTMLCanvasElement::removeObserver(CanvasObserver* observer)
150 {
151     m_observers.remove(observer);
152 }
153
154 void HTMLCanvasElement::setHeight(int value)
155 {
156     setAttribute(heightAttr, String::number(value));
157 }
158
159 void HTMLCanvasElement::setWidth(int value)
160 {
161     setAttribute(widthAttr, String::number(value));
162 }
163
164 #if ENABLE(WEBGL)
165 static bool requiresAcceleratedCompositingForWebGL()
166 {
167 #if PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(QT)
168     return false;
169 #else
170     return true;
171 #endif
172
173 }
174 static bool shouldEnableWebGL(Settings* settings)
175 {
176     if (!settings)
177         return false;
178
179     if (!settings->webGLEnabled())
180         return false;
181
182     if (!requiresAcceleratedCompositingForWebGL())
183         return true;
184
185     return settings->acceleratedCompositingEnabled();
186 }
187 #endif
188
189 CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)
190 {
191     // A Canvas can either be "2D" or "webgl" but never both. If you request a 2D canvas and the existing
192     // context is already 2D, just return that. If the existing context is WebGL, then destroy it
193     // before creating a new 2D context. Vice versa when requesting a WebGL canvas. Requesting a
194     // context with any other type string will destroy any existing context.
195     
196     // FIXME: The code depends on the context not going away once created, to prevent JS from
197     // seeing a dangling pointer. So for now we will disallow the context from being changed
198     // once it is created. https://bugs.webkit.org/show_bug.cgi?id=117095
199     if (is2dType(type)) {
200         if (m_context && !m_context->is2d())
201             return 0;
202         if (!m_context) {
203             bool usesDashbardCompatibilityMode = false;
204 #if ENABLE(DASHBOARD_SUPPORT)
205             if (Settings* settings = document().settings())
206                 usesDashbardCompatibilityMode = settings->usesDashboardBackwardCompatibilityMode();
207 #endif
208             m_context = CanvasRenderingContext2D::create(this, document().inQuirksMode(), usesDashbardCompatibilityMode);
209 #if USE(IOSURFACE_CANVAS_BACKING_STORE) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING))
210             // Need to make sure a RenderLayer and compositing layer get created for the Canvas
211             setNeedsStyleRecalc(SyntheticStyleChange);
212 #endif
213         }
214         return m_context.get();
215     }
216 #if ENABLE(WEBGL)
217     if (shouldEnableWebGL(document().settings())) {
218
219         if (is3dType(type)) {
220             if (m_context && !m_context->is3d())
221                 return 0;
222             if (!m_context) {
223                 m_context = WebGLRenderingContext::create(this, static_cast<WebGLContextAttributes*>(attrs));
224                 if (m_context) {
225                     // Need to make sure a RenderLayer and compositing layer get created for the Canvas
226                     setNeedsStyleRecalc(SyntheticStyleChange);
227                 }
228             }
229             return m_context.get();
230         }
231     }
232 #else
233     UNUSED_PARAM(attrs);
234 #endif
235     return 0;
236 }
237     
238 bool HTMLCanvasElement::supportsContext(const String& type, CanvasContextAttributes*)
239 {
240     // FIXME: Provide implementation that accounts for attributes. Bugzilla bug 117093
241     // https://bugs.webkit.org/show_bug.cgi?id=117093
242
243     // FIXME: The code depends on the context not going away once created (as getContext
244     // is implemented under this assumption) https://bugs.webkit.org/show_bug.cgi?id=117095
245     if (is2dType(type))
246         return !m_context || m_context->is2d();
247
248 #if ENABLE(WEBGL)
249     if (shouldEnableWebGL(document().settings())) {
250         if (is3dType(type))
251             return !m_context || m_context->is3d();
252     }
253 #endif
254     return false;
255 }
256
257 bool HTMLCanvasElement::is2dType(const String& type)
258 {
259     return type == "2d";
260 }
261
262 #if ENABLE(WEBGL)
263 bool HTMLCanvasElement::is3dType(const String& type)
264 {
265     // Accept the legacy "webkit-3d" name as well as the provisional "experimental-webgl" name.
266     return type == "webkit-3d" || type == "experimental-webgl";
267 }
268 #endif
269
270 void HTMLCanvasElement::didDraw(const FloatRect& rect)
271 {
272     clearCopiedImage();
273
274     if (RenderBox* ro = renderBox()) {
275         FloatRect destRect = ro->contentBoxRect();
276         FloatRect r = mapRect(rect, FloatRect(0, 0, size().width(), size().height()), destRect);
277         r.intersect(destRect);
278         if (r.isEmpty() || m_dirtyRect.contains(r))
279             return;
280
281         m_dirtyRect.unite(r);
282         ro->repaintRectangle(enclosingIntRect(m_dirtyRect));
283     }
284
285     notifyObserversCanvasChanged(rect);
286 }
287
288 void HTMLCanvasElement::notifyObserversCanvasChanged(const FloatRect& rect)
289 {
290     HashSet<CanvasObserver*>::iterator end = m_observers.end();
291     for (HashSet<CanvasObserver*>::iterator it = m_observers.begin(); it != end; ++it)
292         (*it)->canvasChanged(this, rect);
293 }
294
295 void HTMLCanvasElement::reset()
296 {
297     if (m_ignoreReset)
298         return;
299
300     bool ok;
301     bool hadImageBuffer = hasCreatedImageBuffer();
302
303     int w = getAttribute(widthAttr).toInt(&ok);
304     if (!ok || w < 0)
305         w = DefaultWidth;
306
307     int h = getAttribute(heightAttr).toInt(&ok);
308     if (!ok || h < 0)
309         h = DefaultHeight;
310
311     if (m_contextStateSaver) {
312         // Reset to the initial graphics context state.
313         m_contextStateSaver->restore();
314         m_contextStateSaver->save();
315     }
316
317     if (m_context && m_context->is2d()) {
318         CanvasRenderingContext2D* context2D = static_cast<CanvasRenderingContext2D*>(m_context.get());
319         context2D->reset();
320     }
321
322     IntSize oldSize = size();
323     IntSize newSize(w, h);
324     float newDeviceScaleFactor = targetDeviceScaleFactor();
325
326     // If the size of an existing buffer matches, we can just clear it instead of reallocating.
327     // This optimization is only done for 2D canvases for now.
328     if (m_hasCreatedImageBuffer && oldSize == newSize && m_deviceScaleFactor == newDeviceScaleFactor && m_context && m_context->is2d()) {
329         if (!m_didClearImageBuffer)
330             clearImageBuffer();
331         return;
332     }
333
334     m_deviceScaleFactor = newDeviceScaleFactor;
335
336     setSurfaceSize(newSize);
337
338 #if ENABLE(WEBGL)
339     if (m_context && m_context->is3d() && oldSize != size())
340         static_cast<WebGLRenderingContext*>(m_context.get())->reshape(width(), height());
341 #endif
342
343     if (RenderObject* renderer = this->renderer()) {
344         if (m_rendererIsCanvas) {
345             if (oldSize != size()) {
346                 toRenderHTMLCanvas(renderer)->canvasSizeChanged();
347 #if USE(ACCELERATED_COMPOSITING)
348                 if (renderBox() && renderBox()->hasAcceleratedCompositing())
349                     renderBox()->contentChanged(CanvasChanged);
350 #endif
351             }
352             if (hadImageBuffer)
353                 renderer->repaint();
354         }
355     }
356
357     HashSet<CanvasObserver*>::iterator end = m_observers.end();
358     for (HashSet<CanvasObserver*>::iterator it = m_observers.begin(); it != end; ++it)
359         (*it)->canvasResized(this);
360 }
361
362 float HTMLCanvasElement::targetDeviceScaleFactor() const
363 {
364 #if ENABLE(HIGH_DPI_CANVAS)
365     return document().frame() ? document().frame()->page()->deviceScaleFactor() : 1;
366 #else
367     return 1;
368 #endif
369 }
370
371 bool HTMLCanvasElement::paintsIntoCanvasBuffer() const
372 {
373     ASSERT(m_context);
374 #if USE(IOSURFACE_CANVAS_BACKING_STORE)
375     if (m_context->is2d())
376         return true;
377 #endif
378
379 #if USE(ACCELERATED_COMPOSITING)
380     if (!m_context->isAccelerated())
381         return true;
382
383     if (renderBox() && renderBox()->hasAcceleratedCompositing())
384         return false;
385 #endif
386     return true;
387 }
388
389
390 void HTMLCanvasElement::paint(GraphicsContext* context, const LayoutRect& r, bool useLowQualityScale)
391 {
392     // Clear the dirty rect
393     m_dirtyRect = FloatRect();
394
395     if (context->paintingDisabled())
396         return;
397     
398     if (m_context) {
399         if (!paintsIntoCanvasBuffer() && !document().printing())
400             return;
401         m_context->paintRenderingResultsToCanvas();
402     }
403
404     if (hasCreatedImageBuffer()) {
405         ImageBuffer* imageBuffer = buffer();
406         if (imageBuffer) {
407             if (m_presentedImage) {
408                 ImageOrientationDescription orientationDescription;
409 #if ENABLE(CSS_IMAGE_ORIENTATION)
410                 orientationDescription.setImageOrientationEnum(renderer()->style()->imageOrientation());
411 #endif 
412                 context->drawImage(m_presentedImage.get(), ColorSpaceDeviceRGB, pixelSnappedIntRect(r), CompositeSourceOver, orientationDescription, useLowQualityScale);
413             } else
414                 context->drawImageBuffer(imageBuffer, ColorSpaceDeviceRGB, pixelSnappedIntRect(r), CompositeSourceOver, BlendModeNormal, useLowQualityScale);
415         }
416     }
417
418 #if ENABLE(WEBGL)    
419     if (is3D())
420         static_cast<WebGLRenderingContext*>(m_context.get())->markLayerComposited();
421 #endif
422 }
423
424 #if ENABLE(WEBGL)
425 bool HTMLCanvasElement::is3D() const
426 {
427     return m_context && m_context->is3d();
428 }
429 #endif
430
431 void HTMLCanvasElement::makeRenderingResultsAvailable()
432 {
433     if (m_context)
434         m_context->paintRenderingResultsToCanvas();
435 }
436
437 void HTMLCanvasElement::makePresentationCopy()
438 {
439     if (!m_presentedImage) {
440         // The buffer contains the last presented data, so save a copy of it.
441         m_presentedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
442     }
443 }
444
445 void HTMLCanvasElement::clearPresentationCopy()
446 {
447     m_presentedImage.clear();
448 }
449
450 void HTMLCanvasElement::setSurfaceSize(const IntSize& size)
451 {
452     m_size = size;
453     m_hasCreatedImageBuffer = false;
454     m_contextStateSaver.clear();
455     m_imageBuffer.clear();
456     clearCopiedImage();
457 }
458
459 String HTMLCanvasElement::toEncodingMimeType(const String& mimeType)
460 {
461     String lowercaseMimeType = mimeType.lower();
462
463     // FIXME: Make isSupportedImageMIMETypeForEncoding threadsafe (to allow this method to be used on a worker thread).
464     if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(lowercaseMimeType))
465         lowercaseMimeType = "image/png";
466
467     return lowercaseMimeType;
468 }
469
470 String HTMLCanvasElement::toDataURL(const String& mimeType, const double* quality, ExceptionCode& ec)
471 {
472     if (!m_originClean) {
473         ec = SECURITY_ERR;
474         return String();
475     }
476
477     if (m_size.isEmpty() || !buffer())
478         return String("data:,");
479
480     String encodingMimeType = toEncodingMimeType(mimeType);
481
482 #if USE(CG)
483     // Try to get ImageData first, as that may avoid lossy conversions.
484     RefPtr<ImageData> imageData = getImageData();
485
486     if (imageData)
487         return ImageDataToDataURL(*imageData, encodingMimeType, quality);
488 #endif
489
490     makeRenderingResultsAvailable();
491
492     return buffer()->toDataURL(encodingMimeType, quality);
493 }
494
495 PassRefPtr<ImageData> HTMLCanvasElement::getImageData()
496 {
497     if (!m_context || !m_context->is3d())
498        return 0;
499
500 #if ENABLE(WEBGL)    
501     WebGLRenderingContext* ctx = static_cast<WebGLRenderingContext*>(m_context.get());
502
503     return ctx->paintRenderingResultsToImageData();
504 #else
505     return 0;
506 #endif
507 }
508
509 FloatRect HTMLCanvasElement::convertLogicalToDevice(const FloatRect& logicalRect) const
510 {
511     FloatRect deviceRect(logicalRect);
512     deviceRect.scale(m_deviceScaleFactor);
513
514     float x = floorf(deviceRect.x());
515     float y = floorf(deviceRect.y());
516     float w = ceilf(deviceRect.maxX() - x);
517     float h = ceilf(deviceRect.maxY() - y);
518     deviceRect.setX(x);
519     deviceRect.setY(y);
520     deviceRect.setWidth(w);
521     deviceRect.setHeight(h);
522
523     return deviceRect;
524 }
525
526 FloatSize HTMLCanvasElement::convertLogicalToDevice(const FloatSize& logicalSize) const
527 {
528     float width = ceilf(logicalSize.width() * m_deviceScaleFactor);
529     float height = ceilf(logicalSize.height() * m_deviceScaleFactor);
530     return FloatSize(width, height);
531 }
532
533 FloatSize HTMLCanvasElement::convertDeviceToLogical(const FloatSize& deviceSize) const
534 {
535     float width = ceilf(deviceSize.width() / m_deviceScaleFactor);
536     float height = ceilf(deviceSize.height() / m_deviceScaleFactor);
537     return FloatSize(width, height);
538 }
539
540 SecurityOrigin* HTMLCanvasElement::securityOrigin() const
541 {
542     return document().securityOrigin();
543 }
544
545 bool HTMLCanvasElement::shouldAccelerate(const IntSize& size) const
546 {
547 #if USE(IOSURFACE_CANVAS_BACKING_STORE)
548     UNUSED_PARAM(size);
549     return document().settings() && document().settings()->canvasUsesAcceleratedDrawing();
550 #elif ENABLE(ACCELERATED_2D_CANVAS)
551     if (m_context && !m_context->is2d())
552         return false;
553
554     Settings* settings = document().settings();
555     if (!settings || !settings->accelerated2dCanvasEnabled())
556         return false;
557
558     // Do not use acceleration for small canvas.
559     if (size.width() * size.height() < settings->minimumAccelerated2dCanvasSize())
560         return false;
561
562     return true;
563 #else
564     UNUSED_PARAM(size);
565     return false;
566 #endif
567 }
568
569 void HTMLCanvasElement::createImageBuffer() const
570 {
571     ASSERT(!m_imageBuffer);
572
573     m_hasCreatedImageBuffer = true;
574     m_didClearImageBuffer = true;
575
576     FloatSize logicalSize = size();
577     FloatSize deviceSize = convertLogicalToDevice(logicalSize);
578     if (!deviceSize.isExpressibleAsIntSize())
579         return;
580
581     if (deviceSize.width() * deviceSize.height() > MaxCanvasArea)
582         return;
583
584     IntSize bufferSize(deviceSize.width(), deviceSize.height());
585     if (!bufferSize.width() || !bufferSize.height())
586         return;
587
588     RenderingMode renderingMode = shouldAccelerate(bufferSize) ? Accelerated : Unaccelerated;
589     m_imageBuffer = ImageBuffer::create(size(), m_deviceScaleFactor, ColorSpaceDeviceRGB, renderingMode);
590     if (!m_imageBuffer)
591         return;
592     m_imageBuffer->context()->setShadowsIgnoreTransforms(true);
593     m_imageBuffer->context()->setImageInterpolationQuality(DefaultInterpolationQuality);
594     if (document().settings() && !document().settings()->antialiased2dCanvasEnabled())
595         m_imageBuffer->context()->setShouldAntialias(false);
596     m_imageBuffer->context()->setStrokeThickness(1);
597     m_contextStateSaver = adoptPtr(new GraphicsContextStateSaver(*m_imageBuffer->context()));
598
599     JSC::JSLockHolder lock(scriptExecutionContext()->vm());
600     size_t numBytes = 4 * m_imageBuffer->internalSize().width() * m_imageBuffer->internalSize().height();
601     scriptExecutionContext()->vm()->heap.reportExtraMemoryCost(numBytes);
602
603 #if USE(IOSURFACE_CANVAS_BACKING_STORE) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING))
604     if (m_context && m_context->is2d())
605         // Recalculate compositing requirements if acceleration state changed.
606         const_cast<HTMLCanvasElement*>(this)->setNeedsStyleRecalc(SyntheticStyleChange);
607 #endif
608 }
609
610 GraphicsContext* HTMLCanvasElement::drawingContext() const
611 {
612     return buffer() ? m_imageBuffer->context() : 0;
613 }
614
615 GraphicsContext* HTMLCanvasElement::existingDrawingContext() const
616 {
617     if (!m_hasCreatedImageBuffer)
618         return 0;
619
620     return drawingContext();
621 }
622
623 ImageBuffer* HTMLCanvasElement::buffer() const
624 {
625     if (!m_hasCreatedImageBuffer)
626         createImageBuffer();
627     return m_imageBuffer.get();
628 }
629
630 Image* HTMLCanvasElement::copiedImage() const
631 {
632     if (!m_copiedImage && buffer()) {
633         if (m_context)
634             m_context->paintRenderingResultsToCanvas();
635         m_copiedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
636     }
637     return m_copiedImage.get();
638 }
639
640 void HTMLCanvasElement::clearImageBuffer() const
641 {
642     ASSERT(m_hasCreatedImageBuffer);
643     ASSERT(!m_didClearImageBuffer);
644     ASSERT(m_context);
645
646     m_didClearImageBuffer = true;
647
648     if (m_context->is2d()) {
649         CanvasRenderingContext2D* context2D = static_cast<CanvasRenderingContext2D*>(m_context.get());
650         // No need to undo transforms/clip/etc. because we are called right after the context is reset.
651         context2D->clearRect(0, 0, width(), height());
652     }
653 }
654
655 void HTMLCanvasElement::clearCopiedImage()
656 {
657     m_copiedImage.clear();
658     m_didClearImageBuffer = false;
659 }
660
661 AffineTransform HTMLCanvasElement::baseTransform() const
662 {
663     ASSERT(m_hasCreatedImageBuffer);
664     FloatSize unscaledSize = size();
665     FloatSize deviceSize = convertLogicalToDevice(unscaledSize);
666     IntSize size(deviceSize.width(), deviceSize.height());
667     AffineTransform transform;
668     if (size.width() && size.height())
669         transform.scaleNonUniform(size.width() / unscaledSize.width(), size.height() / unscaledSize.height());
670     return m_imageBuffer->baseTransform() * transform;
671 }
672
673 }