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