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