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