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