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