2011-05-23 Mike Lawther <mikelawther@chromium.org>
[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 "CanvasStyle.h"
37 #include "Chrome.h"
38 #include "Document.h"
39 #include "ExceptionCode.h"
40 #include "Frame.h"
41 #include "GraphicsContext.h"
42 #include "HTMLNames.h"
43 #include "ImageBuffer.h"
44 #include "ImageData.h"
45 #include "MIMETypeRegistry.h"
46 #include "Page.h"
47 #include "RenderHTMLCanvas.h"
48 #include "Settings.h"
49 #include <math.h>
50 #include <stdio.h>
51
52 #if USE(JSC)
53 #include <runtime/JSLock.h>
54 #endif
55
56 #if ENABLE(WEBGL)    
57 #include "WebGLContextAttributes.h"
58 #include "WebGLRenderingContext.h"
59 #endif
60
61 namespace WebCore {
62
63 using namespace HTMLNames;
64
65 // These values come from the WhatWG spec.
66 static const int DefaultWidth = 300;
67 static const int DefaultHeight = 150;
68
69 // Firefox limits width/height to 32767 pixels, but slows down dramatically before it
70 // reaches that limit. We limit by area instead, giving us larger maximum dimensions,
71 // in exchange for a smaller maximum canvas size.
72 static const float MaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels
73
74 //In Skia, we will also limit width/height to 32767.
75 static const float MaxSkiaDim = 32767.0F; // Maximum width/height in CSS pixels.
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_pageScaleFactor(document->frame() ? document->frame()->page()->chrome()->scaleFactor() : 1)
83     , m_originClean(true)
84     , m_hasCreatedImageBuffer(false)
85 {
86     ASSERT(hasTagName(canvasTag));
87 }
88
89 PassRefPtr<HTMLCanvasElement> HTMLCanvasElement::create(Document* document)
90 {
91     return adoptRef(new HTMLCanvasElement(canvasTag, document));
92 }
93
94 PassRefPtr<HTMLCanvasElement> HTMLCanvasElement::create(const QualifiedName& tagName, Document* document)
95 {
96     return adoptRef(new HTMLCanvasElement(tagName, document));
97 }
98
99 HTMLCanvasElement::~HTMLCanvasElement()
100 {
101     HashSet<CanvasObserver*>::iterator end = m_observers.end();
102     for (HashSet<CanvasObserver*>::iterator it = m_observers.begin(); it != end; ++it)
103         (*it)->canvasDestroyed(this);
104
105     m_context.clear(); // Ensure this goes away before the ImageBuffer.
106 }
107
108 void HTMLCanvasElement::parseMappedAttribute(Attribute* attr)
109 {
110     const QualifiedName& attrName = attr->name();
111     if (attrName == widthAttr || attrName == heightAttr)
112         reset();
113     HTMLElement::parseMappedAttribute(attr);
114 }
115
116 RenderObject* HTMLCanvasElement::createRenderer(RenderArena* arena, RenderStyle* style)
117 {
118     Frame* frame = document()->frame();
119     if (frame && frame->script()->canExecuteScripts(NotAboutToExecuteScript)) {
120         m_rendererIsCanvas = true;
121         return new (arena) RenderHTMLCanvas(this);
122     }
123
124     m_rendererIsCanvas = false;
125     return HTMLElement::createRenderer(arena, style);
126 }
127
128 void HTMLCanvasElement::addObserver(CanvasObserver* observer)
129 {
130     m_observers.add(observer);
131 }
132
133 void HTMLCanvasElement::removeObserver(CanvasObserver* observer)
134 {
135     m_observers.remove(observer);
136 }
137
138 void HTMLCanvasElement::setHeight(int value)
139 {
140     setAttribute(heightAttr, String::number(value));
141 }
142
143 void HTMLCanvasElement::setWidth(int value)
144 {
145     setAttribute(widthAttr, String::number(value));
146 }
147
148 CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)
149 {
150     // A Canvas can either be "2D" or "webgl" but never both. If you request a 2D canvas and the existing
151     // context is already 2D, just return that. If the existing context is WebGL, then destroy it
152     // before creating a new 2D context. Vice versa when requesting a WebGL canvas. Requesting a
153     // context with any other type string will destroy any existing context.
154     
155     // FIXME - The code depends on the context not going away once created, to prevent JS from
156     // seeing a dangling pointer. So for now we will disallow the context from being changed
157     // once it is created.
158     if (type == "2d") {
159         if (m_context && !m_context->is2d())
160             return 0;
161         if (!m_context) {
162             bool usesDashbardCompatibilityMode = false;
163 #if ENABLE(DASHBOARD_SUPPORT)
164             if (Settings* settings = document()->settings())
165                 usesDashbardCompatibilityMode = settings->usesDashboardBackwardCompatibilityMode();
166 #endif
167             m_context = CanvasRenderingContext2D::create(this, document()->inQuirksMode(), usesDashbardCompatibilityMode);
168 #if USE(IOSURFACE_CANVAS_BACKING_STORE) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING))
169             if (m_context) {
170                 // Need to make sure a RenderLayer and compositing layer get created for the Canvas
171                 setNeedsStyleRecalc(SyntheticStyleChange);
172             }
173 #endif
174         }
175         return m_context.get();
176     }
177 #if ENABLE(WEBGL)    
178     Settings* settings = document()->settings();
179     if (settings && settings->webGLEnabled()
180 #if !PLATFORM(CHROMIUM) && !PLATFORM(GTK)
181         && settings->acceleratedCompositingEnabled()
182 #endif
183         ) {
184         // Accept the legacy "webkit-3d" name as well as the provisional "experimental-webgl" name.
185         // Once ratified, we will also accept "webgl" as the context name.
186         if ((type == "webkit-3d") ||
187             (type == "experimental-webgl")) {
188             if (m_context && !m_context->is3d())
189                 return 0;
190             if (!m_context) {
191                 m_context = WebGLRenderingContext::create(this, static_cast<WebGLContextAttributes*>(attrs));
192                 if (m_context) {
193                     // Need to make sure a RenderLayer and compositing layer get created for the Canvas
194                     setNeedsStyleRecalc(SyntheticStyleChange);
195                 }
196             }
197             return m_context.get();
198         }
199     }
200 #else
201     UNUSED_PARAM(attrs);
202 #endif
203     return 0;
204 }
205
206 void HTMLCanvasElement::didDraw(const FloatRect& rect)
207 {
208     m_copiedImage.clear(); // Clear our image snapshot if we have one.
209
210     if (RenderBox* ro = renderBox()) {
211         FloatRect destRect = ro->contentBoxRect();
212         FloatRect r = mapRect(rect, FloatRect(0, 0, size().width(), size().height()), destRect);
213         r.intersect(destRect);
214         if (r.isEmpty() || m_dirtyRect.contains(r))
215             return;
216
217         m_dirtyRect.unite(r);
218         ro->repaintRectangle(enclosingIntRect(m_dirtyRect));
219     }
220
221     HashSet<CanvasObserver*>::iterator end = m_observers.end();
222     for (HashSet<CanvasObserver*>::iterator it = m_observers.begin(); it != end; ++it)
223         (*it)->canvasChanged(this, rect);
224 }
225
226 void HTMLCanvasElement::reset()
227 {
228     if (m_ignoreReset)
229         return;
230
231     bool ok;
232     bool hadImageBuffer = hasCreatedImageBuffer();
233     int w = getAttribute(widthAttr).toInt(&ok);
234     if (!ok || w < 0)
235         w = DefaultWidth;
236     int h = getAttribute(heightAttr).toInt(&ok);
237     if (!ok || h < 0)
238         h = DefaultHeight;
239
240     IntSize oldSize = size();
241     setSurfaceSize(IntSize(w, h)); // The image buffer gets cleared here.
242
243 #if ENABLE(WEBGL)
244     if (m_context && m_context->is3d() && oldSize != size())
245         static_cast<WebGLRenderingContext*>(m_context.get())->reshape(width(), height());
246 #endif
247
248     if (m_context && m_context->is2d())
249         static_cast<CanvasRenderingContext2D*>(m_context.get())->reset();
250
251     if (RenderObject* renderer = this->renderer()) {
252         if (m_rendererIsCanvas) {
253             if (oldSize != size())
254                 toRenderHTMLCanvas(renderer)->canvasSizeChanged();
255             if (hadImageBuffer)
256                 renderer->repaint();
257         }
258     }
259
260     HashSet<CanvasObserver*>::iterator end = m_observers.end();
261     for (HashSet<CanvasObserver*>::iterator it = m_observers.begin(); it != end; ++it)
262         (*it)->canvasResized(this);
263 }
264
265 void HTMLCanvasElement::paint(GraphicsContext* context, const IntRect& r, bool useLowQualityScale)
266 {
267     // Clear the dirty rect
268     m_dirtyRect = FloatRect();
269
270     if (context->paintingDisabled())
271         return;
272     
273     if (m_context) {
274         if (!m_context->paintsIntoCanvasBuffer())
275             return;
276         m_context->paintRenderingResultsToCanvas();
277     }
278
279     if (hasCreatedImageBuffer()) {
280         ImageBuffer* imageBuffer = buffer();
281         if (imageBuffer) {
282             if (m_presentedImage)
283                 context->drawImage(m_presentedImage.get(), ColorSpaceDeviceRGB, r, CompositeSourceOver, useLowQualityScale);
284             else if (imageBuffer->drawsUsingCopy())
285                 context->drawImage(copiedImage(), ColorSpaceDeviceRGB, r, CompositeSourceOver, useLowQualityScale);
286             else
287                 context->drawImageBuffer(imageBuffer, ColorSpaceDeviceRGB, r, CompositeSourceOver, useLowQualityScale);
288         }
289     }
290
291 #if ENABLE(WEBGL)    
292     if (is3D())
293         static_cast<WebGLRenderingContext*>(m_context.get())->markLayerComposited();
294 #endif
295 }
296
297 #if ENABLE(WEBGL)
298 bool HTMLCanvasElement::is3D() const
299 {
300     return m_context && m_context->is3d();
301 }
302 #endif
303
304 void HTMLCanvasElement::makeRenderingResultsAvailable()
305 {
306     if (m_context)
307         m_context->paintRenderingResultsToCanvas();
308 }
309
310 void HTMLCanvasElement::makePresentationCopy()
311 {
312     if (!m_presentedImage) {
313         // The buffer contains the last presented data, so save a copy of it.
314         m_presentedImage = buffer()->copyImage();
315     }
316 }
317
318 void HTMLCanvasElement::clearPresentationCopy()
319 {
320     m_presentedImage.clear();
321 }
322
323 void HTMLCanvasElement::setSurfaceSize(const IntSize& size)
324 {
325     m_size = size;
326     m_hasCreatedImageBuffer = false;
327     m_imageBuffer.clear();
328     m_copiedImage.clear();
329 }
330
331 String HTMLCanvasElement::toDataURL(const String& mimeType, const double* quality, ExceptionCode& ec)
332 {
333     if (!m_originClean) {
334         ec = SECURITY_ERR;
335         return String();
336     }
337
338     if (m_size.isEmpty() || !buffer())
339         return String("data:,");
340
341     String lowercaseMimeType = mimeType.lower();
342
343     // FIXME: Make isSupportedImageMIMETypeForEncoding threadsafe (to allow this method to be used on a worker thread).
344     if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(lowercaseMimeType))
345         lowercaseMimeType = "image/png";
346
347 #if USE(CG) || USE(SKIA)
348     // Try to get ImageData first, as that may avoid lossy conversions.
349     RefPtr<ImageData> imageData = getImageData();
350
351     if (imageData)
352         return ImageDataToDataURL(*imageData, lowercaseMimeType, quality);
353 #endif
354
355     makeRenderingResultsAvailable();
356       
357     return buffer()->toDataURL(lowercaseMimeType, quality);
358 }
359
360 PassRefPtr<ImageData> HTMLCanvasElement::getImageData()
361 {
362     if (!m_context || !m_context->is3d())
363        return 0;
364
365 #if ENABLE(WEBGL)    
366     WebGLRenderingContext* ctx = static_cast<WebGLRenderingContext*>(m_context.get());
367
368     return ctx->paintRenderingResultsToImageData();
369 #else
370     return 0;
371 #endif
372 }
373
374 IntRect HTMLCanvasElement::convertLogicalToDevice(const FloatRect& logicalRect) const
375 {
376     float left = floorf(logicalRect.x() * m_pageScaleFactor);
377     float top = floorf(logicalRect.y() * m_pageScaleFactor);
378     float right = ceilf(logicalRect.maxX() * m_pageScaleFactor);
379     float bottom = ceilf(logicalRect.maxY() * m_pageScaleFactor);
380     
381     return IntRect(IntPoint(left, top), convertToValidDeviceSize(right - left, bottom - top));
382 }
383
384 IntSize HTMLCanvasElement::convertLogicalToDevice(const FloatSize& logicalSize) const
385 {
386     return convertToValidDeviceSize(logicalSize.width() * m_pageScaleFactor, logicalSize.height() * m_pageScaleFactor);
387 }
388
389 IntSize HTMLCanvasElement::convertToValidDeviceSize(float width, float height) const
390 {
391     width = ceilf(width);
392     height = ceilf(height);
393     
394     if (width < 1 || height < 1 || width * height > MaxCanvasArea)
395         return IntSize();
396
397 #if USE(SKIA)
398     if (width > MaxSkiaDim || height > MaxSkiaDim)
399         return IntSize();
400 #endif
401
402     return IntSize(width, height);
403 }
404
405 const SecurityOrigin& HTMLCanvasElement::securityOrigin() const
406 {
407     return *document()->securityOrigin();
408 }
409
410 CSSStyleSelector* HTMLCanvasElement::styleSelector()
411 {
412     return document()->styleSelector();
413 }
414
415 void HTMLCanvasElement::createImageBuffer() const
416 {
417     ASSERT(!m_imageBuffer);
418
419     m_hasCreatedImageBuffer = true;
420
421     FloatSize unscaledSize(width(), height());
422     IntSize size = convertLogicalToDevice(unscaledSize);
423     if (!size.width() || !size.height())
424         return;
425
426 #if USE(IOSURFACE_CANVAS_BACKING_STORE)
427     if (document()->settings()->canvasUsesAcceleratedDrawing())
428         m_imageBuffer = ImageBuffer::create(size, ColorSpaceDeviceRGB, Accelerated);
429     else
430         m_imageBuffer = ImageBuffer::create(size, ColorSpaceDeviceRGB, Unaccelerated);
431 #else
432     m_imageBuffer = ImageBuffer::create(size);
433 #endif
434     // The convertLogicalToDevice MaxCanvasArea check should prevent common cases
435     // where ImageBuffer::create() returns 0, however we could still be low on memory.
436     if (!m_imageBuffer)
437         return;
438     m_imageBuffer->context()->scale(FloatSize(size.width() / unscaledSize.width(), size.height() / unscaledSize.height()));
439     m_imageBuffer->context()->setShadowsIgnoreTransforms(true);
440     m_imageBuffer->context()->setImageInterpolationQuality(DefaultInterpolationQuality);
441
442 #if USE(JSC)
443     JSC::JSLock lock(JSC::SilenceAssertionsOnly);
444     scriptExecutionContext()->globalData()->heap.reportExtraMemoryCost(m_imageBuffer->dataSize());
445 #endif
446 }
447
448 GraphicsContext* HTMLCanvasElement::drawingContext() const
449 {
450     return buffer() ? m_imageBuffer->context() : 0;
451 }
452
453 GraphicsContext* HTMLCanvasElement::existingDrawingContext() const
454 {
455     if (!m_hasCreatedImageBuffer)
456         return 0;
457
458     return drawingContext();
459 }
460
461 ImageBuffer* HTMLCanvasElement::buffer() const
462 {
463     if (!m_hasCreatedImageBuffer)
464         createImageBuffer();
465     return m_imageBuffer.get();
466 }
467
468 Image* HTMLCanvasElement::copiedImage() const
469 {
470     if (!m_copiedImage && buffer()) {
471         if (m_context)
472             m_context->paintRenderingResultsToCanvas();
473         m_copiedImage = buffer()->copyImage();
474     }
475     return m_copiedImage.get();
476 }
477
478 void HTMLCanvasElement::clearCopiedImage()
479 {
480     m_copiedImage.clear();
481 }
482
483 AffineTransform HTMLCanvasElement::baseTransform() const
484 {
485     ASSERT(m_hasCreatedImageBuffer);
486     FloatSize unscaledSize(width(), height());
487     IntSize size = convertLogicalToDevice(unscaledSize);
488     AffineTransform transform;
489     if (size.width() && size.height())
490         transform.scaleNonUniform(size.width() / unscaledSize.width(), size.height() / unscaledSize.height());
491     return m_imageBuffer->baseTransform() * transform;
492 }
493
494 }