0ad20b1c15dd782b59e71bf42f6a8bb202c07f37
[WebKit.git] / Source / WebCore / html / HTMLCanvasElement.cpp
1 /*
2  * Copyright (C) 2004-2017 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 "Blob.h"
32 #include "BlobCallback.h"
33 #include "CanvasGradient.h"
34 #include "CanvasPattern.h"
35 #include "CanvasRenderingContext2D.h"
36 #include "DisplayListDrawingContext.h"
37 #include "Document.h"
38 #include "EventNames.h"
39 #include "Frame.h"
40 #include "FrameLoaderClient.h"
41 #include "GPUBasedCanvasRenderingContext.h"
42 #include "GeometryUtilities.h"
43 #include "GraphicsContext.h"
44 #include "HTMLNames.h"
45 #include "HTMLParserIdioms.h"
46 #include "ImageBitmapRenderingContext.h"
47 #include "ImageBuffer.h"
48 #include "ImageData.h"
49 #include "InspectorInstrumentation.h"
50 #include "JSDOMConvertDictionary.h"
51 #include "MIMETypeRegistry.h"
52 #include "RenderElement.h"
53 #include "RenderHTMLCanvas.h"
54 #include "ResourceLoadObserver.h"
55 #include "RuntimeEnabledFeatures.h"
56 #include "ScriptController.h"
57 #include "Settings.h"
58 #include "StringAdaptors.h"
59 #include <JavaScriptCore/JSCInlines.h>
60 #include <math.h>
61 #include <wtf/IsoMallocInlines.h>
62 #include <wtf/RAMSize.h>
63 #include <wtf/text/StringBuilder.h>
64
65 #if ENABLE(MEDIA_STREAM)
66 #include "CanvasCaptureMediaStreamTrack.h"
67 #include "MediaStream.h"
68 #endif
69
70 #if ENABLE(WEBGL)
71 #include "WebGLContextAttributes.h"
72 #include "WebGLRenderingContext.h"
73 #endif
74
75 #if ENABLE(WEBGL2)
76 #include "WebGL2RenderingContext.h"
77 #endif
78
79 #if ENABLE(WEBGPU)
80 #include "GPUCanvasContext.h"
81 #endif
82
83 #if ENABLE(WEBXR)
84 #include "DOMWindow.h"
85 #include "Navigator.h"
86 #include "NavigatorWebXR.h"
87 #include "WebXRSystem.h"
88 #endif
89
90 #if PLATFORM(COCOA)
91 #include "MediaSampleAVFObjC.h"
92 #include <pal/cf/CoreMediaSoftLink.h>
93 #endif
94
95 #if USE(CG)
96 #include "ImageBufferUtilitiesCG.h"
97 #endif
98
99 namespace WebCore {
100
101 WTF_MAKE_ISO_ALLOCATED_IMPL(HTMLCanvasElement);
102
103 using namespace PAL;
104 using namespace HTMLNames;
105
106 // These values come from the WhatWG/W3C HTML spec.
107 const int defaultWidth = 300;
108 const int defaultHeight = 150;
109
110 // Firefox limits width/height to 32767 pixels, but slows down dramatically before it
111 // reaches that limit. We limit by area instead, giving us larger maximum dimensions,
112 // in exchange for a smaller maximum canvas size. The maximum canvas size is in device pixels.
113 #if PLATFORM(IOS_FAMILY)
114 const unsigned maxCanvasArea = 4096 * 4096;
115 #else
116 const unsigned maxCanvasArea = 16384 * 16384;
117 #endif
118
119 static size_t maxActivePixelMemoryForTesting = 0;
120
121 HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document& document)
122     : HTMLElement(tagName, document)
123     , CanvasBase(IntSize(defaultWidth, defaultHeight))
124     , ActiveDOMObject(document)
125 {
126     ASSERT(hasTagName(canvasTag));
127 }
128
129 Ref<HTMLCanvasElement> HTMLCanvasElement::create(Document& document)
130 {
131     auto canvas = adoptRef(*new HTMLCanvasElement(canvasTag, document));
132     canvas->suspendIfNeeded();
133     return canvas;
134 }
135
136 Ref<HTMLCanvasElement> HTMLCanvasElement::create(const QualifiedName& tagName, Document& document)
137 {
138     auto canvas = adoptRef(*new HTMLCanvasElement(tagName, document));
139     canvas->suspendIfNeeded();
140     return canvas;
141 }
142
143 HTMLCanvasElement::~HTMLCanvasElement()
144 {
145     // FIXME: This has to be called here because CSSCanvasValue::CanvasObserverProxy::canvasDestroyed()
146     // downcasts the CanvasBase object to HTMLCanvasElement. That invokes virtual methods, which should be
147     // avoided in destructors, but works as long as it's done before HTMLCanvasElement destructs completely.
148     notifyObserversCanvasDestroyed();
149
150     m_context = nullptr; // Ensure this goes away before the ImageBuffer.
151     setImageBuffer(nullptr);
152 }
153
154 void HTMLCanvasElement::parseAttribute(const QualifiedName& name, const AtomString& value)
155 {
156     if (name == widthAttr || name == heightAttr)
157         reset();
158     HTMLElement::parseAttribute(name, value);
159 }
160
161 RenderPtr<RenderElement> HTMLCanvasElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition& insertionPosition)
162 {
163     RefPtr<Frame> frame = document().frame();
164     if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript))
165         return createRenderer<RenderHTMLCanvas>(*this, WTFMove(style));
166     return HTMLElement::createElementRenderer(WTFMove(style), insertionPosition);
167 }
168
169 bool HTMLCanvasElement::canContainRangeEndPoint() const
170 {
171     return false;
172 }
173
174 bool HTMLCanvasElement::canStartSelection() const
175 {
176     return false;
177 }
178
179 ExceptionOr<void> HTMLCanvasElement::setHeight(unsigned value)
180 {
181     if (m_context && m_context->isPlaceholder())
182         return Exception { InvalidStateError };
183     setAttributeWithoutSynchronization(heightAttr, AtomString::number(limitToOnlyHTMLNonNegative(value, defaultHeight)));
184     return { };
185 }
186
187 ExceptionOr<void> HTMLCanvasElement::setWidth(unsigned value)
188 {
189     if (m_context && m_context->isPlaceholder())
190         return Exception { InvalidStateError };
191     setAttributeWithoutSynchronization(widthAttr, AtomString::number(limitToOnlyHTMLNonNegative(value, defaultWidth)));
192     return { };
193 }
194
195 void HTMLCanvasElement::setSize(const IntSize& newSize)
196 {
197     if (newSize == size())
198         return;
199
200     m_ignoreReset = true;
201     setWidth(newSize.width());
202     setHeight(newSize.height());
203     m_ignoreReset = false;
204     reset();
205 }
206
207 static inline size_t maxActivePixelMemory()
208 {
209     if (maxActivePixelMemoryForTesting)
210         return maxActivePixelMemoryForTesting;
211
212     static size_t maxPixelMemory;
213     static std::once_flag onceFlag;
214     std::call_once(onceFlag, [] {
215 #if PLATFORM(IOS_FAMILY)
216         maxPixelMemory = ramSize() / 4;
217 #else
218         maxPixelMemory = std::max(ramSize() / 4, 2151 * MB);
219 #endif
220     });
221
222     return maxPixelMemory;
223 }
224
225 void HTMLCanvasElement::setMaxPixelMemoryForTesting(size_t size)
226 {
227     maxActivePixelMemoryForTesting = size;
228 }
229
230 ExceptionOr<Optional<RenderingContext>> HTMLCanvasElement::getContext(JSC::JSGlobalObject& state, const String& contextId, Vector<JSC::Strong<JSC::Unknown>>&& arguments)
231 {
232     if (m_context) {
233         if (m_context->isPlaceholder())
234             return Exception { InvalidStateError };
235
236         if (m_context->is2d()) {
237             if (!is2dType(contextId))
238                 return Optional<RenderingContext> { WTF::nullopt };
239             return Optional<RenderingContext> { RefPtr<CanvasRenderingContext2D> { &downcast<CanvasRenderingContext2D>(*m_context) } };
240         }
241
242         if (m_context->isBitmapRenderer()) {
243             if (!isBitmapRendererType(contextId))
244                 return Optional<RenderingContext> { WTF::nullopt };
245             return Optional<RenderingContext> { RefPtr<ImageBitmapRenderingContext> { &downcast<ImageBitmapRenderingContext>(*m_context) } };
246         }
247
248 #if ENABLE(WEBGL)
249         if (m_context->isWebGL()) {
250             if (!isWebGLType(contextId))
251                 return Optional<RenderingContext> { WTF::nullopt };
252             if (is<WebGLRenderingContext>(*m_context))
253                 return Optional<RenderingContext> { RefPtr<WebGLRenderingContext> { &downcast<WebGLRenderingContext>(*m_context) } };
254 #if ENABLE(WEBGL2)
255             ASSERT(is<WebGL2RenderingContext>(*m_context));
256             return Optional<RenderingContext> { RefPtr<WebGL2RenderingContext> { &downcast<WebGL2RenderingContext>(*m_context) } };
257 #endif
258         }
259 #endif
260
261 #if ENABLE(WEBGPU)
262         if (m_context->isWebGPU()) {
263             if (!isWebGPUType(contextId))
264                 return Optional<RenderingContext> { WTF::nullopt };
265             return Optional<RenderingContext> { RefPtr<GPUCanvasContext> { &downcast<GPUCanvasContext>(*m_context) } };
266         }
267 #endif
268
269         ASSERT_NOT_REACHED();
270         return Optional<RenderingContext> { WTF::nullopt };
271     }
272
273     if (is2dType(contextId)) {
274         auto context = createContext2d(contextId);
275         if (!context)
276             return Optional<RenderingContext> { WTF::nullopt };
277         return Optional<RenderingContext> { RefPtr<CanvasRenderingContext2D> { context } };
278     }
279
280     if (isBitmapRendererType(contextId)) {
281         auto scope = DECLARE_THROW_SCOPE(state.vm());
282         auto attributes = convert<IDLDictionary<ImageBitmapRenderingContextSettings>>(state, !arguments.isEmpty() ? arguments[0].get() : JSC::jsUndefined());
283         RETURN_IF_EXCEPTION(scope, Exception { ExistingExceptionError });
284
285         auto context = createContextBitmapRenderer(contextId, WTFMove(attributes));
286         if (!context)
287             return Optional<RenderingContext> { WTF::nullopt };
288         return Optional<RenderingContext> { RefPtr<ImageBitmapRenderingContext> { context } };
289     }
290
291 #if ENABLE(WEBGL)
292     if (isWebGLType(contextId)) {
293         auto scope = DECLARE_THROW_SCOPE(state.vm());
294         auto attributes = convert<IDLDictionary<WebGLContextAttributes>>(state, !arguments.isEmpty() ? arguments[0].get() : JSC::jsUndefined());
295         RETURN_IF_EXCEPTION(scope, Exception { ExistingExceptionError });
296
297         auto context = createContextWebGL(contextId, WTFMove(attributes));
298         if (!context)
299             return Optional<RenderingContext> { WTF::nullopt };
300
301         if (is<WebGLRenderingContext>(*context))
302             return Optional<RenderingContext> { RefPtr<WebGLRenderingContext> { &downcast<WebGLRenderingContext>(*context) } };
303 #if ENABLE(WEBGL2)
304         ASSERT(is<WebGL2RenderingContext>(*context));
305         return Optional<RenderingContext> { RefPtr<WebGL2RenderingContext> { &downcast<WebGL2RenderingContext>(*context) } };
306 #endif
307     }
308 #endif
309
310 #if ENABLE(WEBGPU)
311     if (isWebGPUType(contextId)) {
312         auto context = createContextWebGPU(contextId);
313         if (!context)
314             return Optional<RenderingContext> { WTF::nullopt };
315         return Optional<RenderingContext> { RefPtr<GPUCanvasContext> { context } };
316     }
317 #endif
318
319     return Optional<RenderingContext> { WTF::nullopt };
320 }
321
322 CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type)
323 {
324     if (HTMLCanvasElement::is2dType(type))
325         return getContext2d(type);
326
327     if (HTMLCanvasElement::isBitmapRendererType(type))
328         return getContextBitmapRenderer(type);
329
330 #if ENABLE(WEBGL)
331     if (HTMLCanvasElement::isWebGLType(type))
332         return getContextWebGL(type);
333 #endif
334
335 #if ENABLE(WEBGPU)
336     if (HTMLCanvasElement::isWebGPUType(type))
337         return getContextWebGPU(type);
338 #endif
339
340     return nullptr;
341 }
342
343 bool HTMLCanvasElement::is2dType(const String& type)
344 {
345     return type == "2d";
346 }
347
348 CanvasRenderingContext2D* HTMLCanvasElement::createContext2d(const String& type)
349 {
350     ASSERT_UNUSED(HTMLCanvasElement::is2dType(type), type);
351     ASSERT(!m_context);
352
353     // Make sure we don't use more pixel memory than the system can support.
354     size_t requestedPixelMemory = 4 * width() * height();
355     if (activePixelMemory() + requestedPixelMemory > maxActivePixelMemory()) {
356         StringBuilder stringBuilder;
357         stringBuilder.appendLiteral("Total canvas memory use exceeds the maximum limit (");
358         stringBuilder.appendNumber(maxActivePixelMemory() / 1024 / 1024);
359         stringBuilder.appendLiteral(" MB).");
360         document().addConsoleMessage(MessageSource::JS, MessageLevel::Warning, stringBuilder.toString());
361         return nullptr;
362     }
363
364     m_context = CanvasRenderingContext2D::create(*this, document().inQuirksMode());
365
366 #if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
367     // Need to make sure a RenderLayer and compositing layer get created for the Canvas.
368     invalidateStyleAndLayerComposition();
369 #endif
370
371     return static_cast<CanvasRenderingContext2D*>(m_context.get());
372 }
373
374 CanvasRenderingContext2D* HTMLCanvasElement::getContext2d(const String& type)
375 {
376     ASSERT_UNUSED(HTMLCanvasElement::is2dType(type), type);
377
378     if (m_context && !m_context->is2d())
379         return nullptr;
380
381     if (!m_context)
382         return createContext2d(type);
383     return static_cast<CanvasRenderingContext2D*>(m_context.get());
384 }
385
386 #if ENABLE(WEBGL)
387
388 static bool requiresAcceleratedCompositingForWebGL()
389 {
390 #if PLATFORM(GTK) || PLATFORM(WIN_CAIRO)
391     return false;
392 #else
393     return true;
394 #endif
395
396 }
397 static bool shouldEnableWebGL(const Settings& settings)
398 {
399     if (!settings.webGLEnabled())
400         return false;
401
402     if (!requiresAcceleratedCompositingForWebGL())
403         return true;
404
405     return settings.acceleratedCompositingEnabled();
406 }
407
408 bool HTMLCanvasElement::isWebGLType(const String& type)
409 {
410     // Retain support for the legacy "webkit-3d" name.
411     return type == "webgl" || type == "experimental-webgl"
412 #if ENABLE(WEBGL2)
413         || type == "webgl2"
414 #endif
415         || type == "webkit-3d";
416 }
417
418 WebGLRenderingContextBase* HTMLCanvasElement::createContextWebGL(const String& type, WebGLContextAttributes&& attrs)
419 {
420     ASSERT(HTMLCanvasElement::isWebGLType(type));
421     ASSERT(!m_context);
422
423     if (!shouldEnableWebGL(document().settings()))
424         return nullptr;
425
426 #if ENABLE(WEBXR)
427     // https://immersive-web.github.io/webxr/#xr-compatible
428     if (attrs.xrCompatible) {
429         if (auto* window = document().domWindow())
430             NavigatorWebXR::xr(window->navigator()).ensureImmersiveXRDeviceIsSelected();
431     }
432 #endif
433
434     // TODO(WEBXR): ensure the context is created in a compatible graphics
435     // adapter when there is an active immersive device.
436     m_context = WebGLRenderingContextBase::create(*this, attrs, type);
437     if (m_context) {
438         // Need to make sure a RenderLayer and compositing layer get created for the Canvas.
439         invalidateStyleAndLayerComposition();
440 #if ENABLE(WEBXR)
441         ASSERT(!attrs.xrCompatible || downcast<WebGLRenderingContextBase>(m_context.get())->isXRCompatible());
442 #endif
443     }
444
445     return downcast<WebGLRenderingContextBase>(m_context.get());
446 }
447
448 WebGLRenderingContextBase* HTMLCanvasElement::getContextWebGL(const String& type, WebGLContextAttributes&& attrs)
449 {
450     ASSERT(HTMLCanvasElement::isWebGLType(type));
451
452     if (!shouldEnableWebGL(document().settings()))
453         return nullptr;
454
455     if (m_context && !m_context->isWebGL())
456         return nullptr;
457
458     if (!m_context)
459         return createContextWebGL(type, WTFMove(attrs));
460     return &downcast<WebGLRenderingContextBase>(*m_context);
461 }
462
463 #endif // ENABLE(WEBGL)
464
465 #if ENABLE(WEBGPU)
466
467 bool HTMLCanvasElement::isWebGPUType(const String& type)
468 {
469     return type == "gpu";
470 }
471
472 GPUCanvasContext* HTMLCanvasElement::createContextWebGPU(const String& type)
473 {
474     ASSERT_UNUSED(type, HTMLCanvasElement::isWebGPUType(type));
475     ASSERT(!m_context);
476
477     if (!RuntimeEnabledFeatures::sharedFeatures().webGPUEnabled())
478         return nullptr;
479
480     m_context = GPUCanvasContext::create(*this);
481     if (m_context) {
482         // Need to make sure a RenderLayer and compositing layer get created for the Canvas.
483         invalidateStyleAndLayerComposition();
484     }
485
486     return static_cast<GPUCanvasContext*>(m_context.get());
487 }
488
489 GPUCanvasContext* HTMLCanvasElement::getContextWebGPU(const String& type)
490 {
491     ASSERT_UNUSED(type, HTMLCanvasElement::isWebGPUType(type));
492
493     if (!RuntimeEnabledFeatures::sharedFeatures().webGPUEnabled())
494         return nullptr;
495
496     if (m_context && !m_context->isWebGPU())
497         return nullptr;
498
499     if (!m_context)
500         return createContextWebGPU(type);
501     return static_cast<GPUCanvasContext*>(m_context.get());
502 }
503
504 #endif // ENABLE(WEBGPU)
505
506 bool HTMLCanvasElement::isBitmapRendererType(const String& type)
507 {
508     return type == "bitmaprenderer";
509 }
510
511 ImageBitmapRenderingContext* HTMLCanvasElement::createContextBitmapRenderer(const String& type, ImageBitmapRenderingContextSettings&& settings)
512 {
513     ASSERT_UNUSED(type, HTMLCanvasElement::isBitmapRendererType(type));
514     ASSERT(!m_context);
515
516     m_context = ImageBitmapRenderingContext::create(*this, WTFMove(settings));
517
518 #if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
519     // Need to make sure a RenderLayer and compositing layer get created for the Canvas.
520     invalidateStyleAndLayerComposition();
521 #endif
522
523     return static_cast<ImageBitmapRenderingContext*>(m_context.get());
524 }
525
526 ImageBitmapRenderingContext* HTMLCanvasElement::getContextBitmapRenderer(const String& type, ImageBitmapRenderingContextSettings&& settings)
527 {
528     ASSERT_UNUSED(type, HTMLCanvasElement::isBitmapRendererType(type));
529     if (!m_context)
530         return createContextBitmapRenderer(type, WTFMove(settings));
531     return static_cast<ImageBitmapRenderingContext*>(m_context.get());
532 }
533
534 void HTMLCanvasElement::didDraw(const FloatRect& rect)
535 {
536     clearCopiedImage();
537
538     FloatRect dirtyRect = rect;
539     if (auto* renderer = renderBox()) {
540         FloatRect destRect;
541         if (is<RenderReplaced>(renderer))
542             destRect = downcast<RenderReplaced>(renderer)->replacedContentRect();
543         else
544             destRect = renderer->contentBoxRect();
545
546         // Inflate dirty rect to cover antialiasing on image buffers.
547         if (drawingContext() && drawingContext()->shouldAntialias())
548             dirtyRect.inflate(1);
549
550         FloatRect r = mapRect(dirtyRect, FloatRect(0, 0, size().width(), size().height()), destRect);
551         r.intersect(destRect);
552
553         if (!r.isEmpty() && !m_dirtyRect.contains(r)) {
554             m_dirtyRect.unite(r);
555             renderer->repaintRectangle(enclosingIntRect(m_dirtyRect));
556         }
557     }
558     notifyObserversCanvasChanged(dirtyRect);
559 }
560
561 void HTMLCanvasElement::reset()
562 {
563     if (m_ignoreReset)
564         return;
565
566     bool hadImageBuffer = hasCreatedImageBuffer();
567
568     int w = limitToOnlyHTMLNonNegative(attributeWithoutSynchronization(widthAttr), defaultWidth);
569     int h = limitToOnlyHTMLNonNegative(attributeWithoutSynchronization(heightAttr), defaultHeight);
570
571     resetGraphicsContextState();
572     if (is<CanvasRenderingContext2D>(m_context.get()))
573         downcast<CanvasRenderingContext2D>(*m_context).reset();
574
575     IntSize oldSize = size();
576     IntSize newSize(w, h);
577     // If the size of an existing buffer matches, we can just clear it instead of reallocating.
578     // This optimization is only done for 2D canvases for now.
579     if (m_hasCreatedImageBuffer && oldSize == newSize && m_context && m_context->is2d()) {
580         if (!m_didClearImageBuffer)
581             clearImageBuffer();
582         return;
583     }
584
585     setSurfaceSize(newSize);
586
587     if (isGPUBased() && oldSize != size())
588         downcast<GPUBasedCanvasRenderingContext>(*m_context).reshape(width(), height());
589
590     auto renderer = this->renderer();
591     if (is<RenderHTMLCanvas>(renderer)) {
592         auto& canvasRenderer = downcast<RenderHTMLCanvas>(*renderer);
593         if (oldSize != size()) {
594             canvasRenderer.canvasSizeChanged();
595             if (canvasRenderer.hasAcceleratedCompositing())
596                 canvasRenderer.contentChanged(CanvasChanged);
597         }
598         if (hadImageBuffer)
599             canvasRenderer.repaint();
600     }
601
602     notifyObserversCanvasResized();
603 }
604
605 bool HTMLCanvasElement::paintsIntoCanvasBuffer() const
606 {
607     ASSERT(m_context);
608 #if USE(IOSURFACE_CANVAS_BACKING_STORE)
609     if (m_context->is2d() || m_context->isBitmapRenderer())
610         return true;
611 #endif
612
613     if (!m_context->isAccelerated())
614         return true;
615
616     if (renderBox() && renderBox()->hasAcceleratedCompositing())
617         return false;
618
619     return true;
620 }
621
622
623 void HTMLCanvasElement::paint(GraphicsContext& context, const LayoutRect& r)
624 {
625     // Clear the dirty rect
626     m_dirtyRect = FloatRect();
627
628     if (!context.paintingDisabled()) {
629         bool shouldPaint = true;
630
631         if (m_context) {
632             shouldPaint = paintsIntoCanvasBuffer() || document().printing();
633             if (shouldPaint)
634                 m_context->paintRenderingResultsToCanvas();
635         }
636
637         if (shouldPaint) {
638             if (hasCreatedImageBuffer()) {
639                 if (m_presentedImage)
640                     context.drawImage(*m_presentedImage, snappedIntRect(r), renderer()->imageOrientation());
641                 else if (ImageBuffer* imageBuffer = buffer())
642                     context.drawImageBuffer(*imageBuffer, snappedIntRect(r));
643             }
644
645             if (isGPUBased())
646                 downcast<GPUBasedCanvasRenderingContext>(*m_context).markLayerComposited();
647         }
648     }
649
650     if (UNLIKELY(m_context && m_context->callTracingActive()))
651         InspectorInstrumentation::didFinishRecordingCanvasFrame(*m_context);
652 }
653
654 bool HTMLCanvasElement::isGPUBased() const
655 {
656     return m_context && m_context->isGPUBased();
657 }
658
659 void HTMLCanvasElement::makePresentationCopy()
660 {
661     if (!m_presentedImage) {
662         // The buffer contains the last presented data, so save a copy of it.
663         m_presentedImage = buffer()->copyImage(CopyBackingStore, PreserveResolution::Yes);
664     }
665 }
666
667 void HTMLCanvasElement::clearPresentationCopy()
668 {
669     m_presentedImage = nullptr;
670 }
671
672 void HTMLCanvasElement::setSurfaceSize(const IntSize& size)
673 {
674     CanvasBase::setSize(size);
675     m_hasCreatedImageBuffer = false;
676     setImageBuffer(nullptr);
677     clearCopiedImage();
678 }
679
680 static String toEncodingMimeType(const String& mimeType)
681 {
682     if (!MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType))
683         return "image/png"_s;
684     return mimeType.convertToASCIILowercase();
685 }
686
687 // https://html.spec.whatwg.org/multipage/canvas.html#a-serialisation-of-the-bitmap-as-a-file
688 static Optional<double> qualityFromJSValue(JSC::JSValue qualityValue)
689 {
690     if (!qualityValue.isNumber())
691         return WTF::nullopt;
692
693     double qualityNumber = qualityValue.asNumber();
694     if (qualityNumber < 0 || qualityNumber > 1)
695         return WTF::nullopt;
696
697     return qualityNumber;
698 }
699
700 ExceptionOr<UncachedString> HTMLCanvasElement::toDataURL(const String& mimeType, JSC::JSValue qualityValue)
701 {
702     if (!originClean())
703         return Exception { SecurityError };
704
705     if (size().isEmpty() || !buffer())
706         return UncachedString { "data:,"_s };
707     if (RuntimeEnabledFeatures::sharedFeatures().webAPIStatisticsEnabled())
708         ResourceLoadObserver::shared().logCanvasRead(document());
709
710     auto encodingMIMEType = toEncodingMimeType(mimeType);
711     auto quality = qualityFromJSValue(qualityValue);
712
713 #if USE(CG)
714     // Try to get ImageData first, as that may avoid lossy conversions.
715     if (auto imageData = getImageData())
716         return UncachedString { dataURL(*imageData, encodingMIMEType, quality) };
717 #endif
718
719     makeRenderingResultsAvailable();
720
721     return UncachedString { buffer()->toDataURL(encodingMIMEType, quality) };
722 }
723
724 ExceptionOr<UncachedString> HTMLCanvasElement::toDataURL(const String& mimeType)
725 {
726     return toDataURL(mimeType, { });
727 }
728
729 ExceptionOr<void> HTMLCanvasElement::toBlob(ScriptExecutionContext& context, Ref<BlobCallback>&& callback, const String& mimeType, JSC::JSValue qualityValue)
730 {
731     if (!originClean())
732         return Exception { SecurityError };
733
734     if (size().isEmpty() || !buffer()) {
735         callback->scheduleCallback(context, nullptr);
736         return { };
737     }
738     if (RuntimeEnabledFeatures::sharedFeatures().webAPIStatisticsEnabled())
739         ResourceLoadObserver::shared().logCanvasRead(document());
740
741     auto encodingMIMEType = toEncodingMimeType(mimeType);
742     auto quality = qualityFromJSValue(qualityValue);
743
744 #if USE(CG)
745     if (auto imageData = getImageData()) {
746         RefPtr<Blob> blob;
747         Vector<uint8_t> blobData = data(*imageData, encodingMIMEType, quality);
748         if (!blobData.isEmpty())
749             blob = Blob::create(WTFMove(blobData), encodingMIMEType);
750         callback->scheduleCallback(context, WTFMove(blob));
751         return { };
752     }
753 #endif
754
755     makeRenderingResultsAvailable();
756
757     RefPtr<Blob> blob;
758     Vector<uint8_t> blobData = buffer()->toData(encodingMIMEType, quality);
759     if (!blobData.isEmpty())
760         blob = Blob::create(WTFMove(blobData), encodingMIMEType);
761     callback->scheduleCallback(context, WTFMove(blob));
762     return { };
763 }
764
765 RefPtr<ImageData> HTMLCanvasElement::getImageData()
766 {
767 #if ENABLE(WEBGL)
768     if (is<WebGLRenderingContextBase>(m_context.get())) {
769         if (RuntimeEnabledFeatures::sharedFeatures().webAPIStatisticsEnabled())
770             ResourceLoadObserver::shared().logCanvasRead(document());
771         return downcast<WebGLRenderingContextBase>(*m_context).paintRenderingResultsToImageData();
772     }
773 #endif
774     return nullptr;
775 }
776
777 #if ENABLE(MEDIA_STREAM)
778
779 RefPtr<MediaSample> HTMLCanvasElement::toMediaSample()
780 {
781     auto* imageBuffer = buffer();
782     if (!imageBuffer)
783         return nullptr;
784     if (RuntimeEnabledFeatures::sharedFeatures().webAPIStatisticsEnabled())
785         ResourceLoadObserver::shared().logCanvasRead(document());
786
787 #if PLATFORM(COCOA)
788     makeRenderingResultsAvailable();
789     return MediaSampleAVFObjC::createImageSample(imageBuffer->toBGRAData(), width(), height());
790 #else
791     return nullptr;
792 #endif
793 }
794
795 ExceptionOr<Ref<MediaStream>> HTMLCanvasElement::captureStream(Document& document, Optional<double>&& frameRequestRate)
796 {
797     if (!originClean())
798         return Exception(SecurityError, "Canvas is tainted"_s);
799     if (RuntimeEnabledFeatures::sharedFeatures().webAPIStatisticsEnabled())
800         ResourceLoadObserver::shared().logCanvasRead(this->document());
801
802     if (frameRequestRate && frameRequestRate.value() < 0)
803         return Exception(NotSupportedError, "frameRequestRate is negative"_s);
804
805     auto track = CanvasCaptureMediaStreamTrack::create(document, *this, WTFMove(frameRequestRate));
806     auto stream =  MediaStream::create(document);
807     stream->addTrack(track);
808     return stream;
809 }
810 #endif
811
812 SecurityOrigin* HTMLCanvasElement::securityOrigin() const
813 {
814     return &document().securityOrigin();
815 }
816
817 bool HTMLCanvasElement::shouldAccelerate(const IntSize& size) const
818 {
819     auto& settings = document().settings();
820
821     auto area = size.area<RecordOverflow>();
822     if (area.hasOverflowed())
823         return false;
824
825     if (area > settings.maximumAccelerated2dCanvasSize())
826         return false;
827
828 #if USE(IOSURFACE_CANVAS_BACKING_STORE)
829     return settings.canvasUsesAcceleratedDrawing();
830 #elif ENABLE(ACCELERATED_2D_CANVAS)
831     if (m_context && !m_context->is2d())
832         return false;
833
834     if (!settings.accelerated2dCanvasEnabled())
835         return false;
836
837     if (area < settings.minimumAccelerated2dCanvasSize())
838         return false;
839
840     return true;
841 #else
842     UNUSED_PARAM(size);
843     return false;
844 #endif
845 }
846
847 void HTMLCanvasElement::setUsesDisplayListDrawing(bool usesDisplayListDrawing)
848 {
849     m_usesDisplayListDrawing = usesDisplayListDrawing;
850 }
851
852 void HTMLCanvasElement::setTracksDisplayListReplay(bool tracksDisplayListReplay)
853 {
854     m_tracksDisplayListReplay = tracksDisplayListReplay;
855
856     if (!buffer())
857         return;
858
859     auto& buffer = *this->buffer();
860     if (buffer.drawingContext())
861         buffer.drawingContext()->setTracksDisplayListReplay(m_tracksDisplayListReplay);
862 }
863
864 String HTMLCanvasElement::displayListAsText(DisplayList::AsTextFlags flags) const
865 {
866     if (!buffer())
867         return String();
868
869     auto& buffer = *this->buffer();
870     if (buffer.drawingContext())
871         return buffer.drawingContext()->displayList().asText(flags);
872
873     return String();
874 }
875
876 String HTMLCanvasElement::replayDisplayListAsText(DisplayList::AsTextFlags flags) const
877 {
878     if (!buffer())
879         return String();
880
881     auto& buffer = *this->buffer();
882     if (buffer.drawingContext() && buffer.drawingContext()->replayedDisplayList())
883         return buffer.drawingContext()->replayedDisplayList()->asText(flags);
884
885     return String();
886 }
887
888 void HTMLCanvasElement::createImageBuffer() const
889 {
890     ASSERT(!hasCreatedImageBuffer());
891
892     m_hasCreatedImageBuffer = true;
893     m_didClearImageBuffer = true;
894
895     // Perform multiplication as floating point to avoid overflow
896     if (float(width()) * height() > maxCanvasArea) {
897         StringBuilder stringBuilder;
898         stringBuilder.appendLiteral("Canvas area exceeds the maximum limit (width * height > ");
899         stringBuilder.appendNumber(maxCanvasArea);
900         stringBuilder.appendLiteral(").");
901         document().addConsoleMessage(MessageSource::JS, MessageLevel::Warning, stringBuilder.toString());
902         return;
903     }
904     
905     // Make sure we don't use more pixel memory than the system can support.
906     size_t requestedPixelMemory = 4 * width() * height();
907     if (activePixelMemory() + requestedPixelMemory > maxActivePixelMemory()) {
908         StringBuilder stringBuilder;
909         stringBuilder.appendLiteral("Total canvas memory use exceeds the maximum limit (");
910         stringBuilder.appendNumber(maxActivePixelMemory() / 1024 / 1024);
911         stringBuilder.appendLiteral(" MB).");
912         document().addConsoleMessage(MessageSource::JS, MessageLevel::Warning, stringBuilder.toString());
913         return;
914     }
915
916     if (!width() || !height())
917         return;
918
919     auto hostWindow = (document().view() && document().view()->root()) ? document().view()->root()->hostWindow() : nullptr;
920
921     auto accelerate = shouldAccelerate(size()) ? ShouldAccelerate::Yes : ShouldAccelerate::No;
922     // FIXME: Add a new setting for DisplayList drawing on canvas.
923     auto useDisplayList = m_usesDisplayListDrawing.valueOr(document().settings().displayListDrawingEnabled()) ? ShouldUseDisplayList::Yes : ShouldUseDisplayList::No;
924     setImageBuffer(ImageBuffer::create(size(), accelerate, useDisplayList, RenderingPurpose::Canvas, 1, ColorSpace::SRGB, hostWindow));
925
926     if (buffer() && buffer()->drawingContext())
927         buffer()->drawingContext()->setTracksDisplayListReplay(m_tracksDisplayListReplay);
928
929 #if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
930     if (m_context && m_context->is2d()) {
931         // Recalculate compositing requirements if acceleration state changed.
932         const_cast<HTMLCanvasElement*>(this)->invalidateStyleAndLayerComposition();
933     }
934 #endif
935 }
936
937 void HTMLCanvasElement::setImageBufferAndMarkDirty(std::unique_ptr<ImageBuffer>&& buffer)
938 {
939     m_hasCreatedImageBuffer = true;
940     setImageBuffer(WTFMove(buffer));
941     didDraw(FloatRect(FloatPoint(), size()));
942 }
943
944 Image* HTMLCanvasElement::copiedImage() const
945 {
946     if (!m_copiedImage && buffer()) {
947         if (m_context)
948             m_context->paintRenderingResultsToCanvas();
949         m_copiedImage = buffer()->copyImage(CopyBackingStore, PreserveResolution::Yes);
950     }
951     return m_copiedImage.get();
952 }
953
954 void HTMLCanvasElement::clearImageBuffer() const
955 {
956     ASSERT(m_hasCreatedImageBuffer);
957     ASSERT(!m_didClearImageBuffer);
958     ASSERT(m_context);
959
960     m_didClearImageBuffer = true;
961
962     if (is<CanvasRenderingContext2D>(*m_context)) {
963         // No need to undo transforms/clip/etc. because we are called right after the context is reset.
964         downcast<CanvasRenderingContext2D>(*m_context).clearRect(0, 0, width(), height());
965     }
966 }
967
968 void HTMLCanvasElement::clearCopiedImage()
969 {
970     m_copiedImage = nullptr;
971     m_didClearImageBuffer = false;
972 }
973
974 const char* HTMLCanvasElement::activeDOMObjectName() const
975 {
976     return "HTMLCanvasElement";
977 }
978
979 bool HTMLCanvasElement::virtualHasPendingActivity() const
980 {
981 #if ENABLE(WEBGL)
982     if (is<WebGLRenderingContextBase>(m_context.get())) {
983         // WebGL rendering context may fire contextlost / contextchange / contextrestored events at any point.
984         return m_hasRelevantWebGLEventListener && !downcast<WebGLRenderingContextBase>(*m_context).isContextUnrecoverablyLost();
985     }
986 #endif
987
988     return false;
989 }
990
991 void HTMLCanvasElement::eventListenersDidChange()
992 {
993 #if ENABLE(WEBGL)
994     m_hasRelevantWebGLEventListener = hasEventListeners(eventNames().webglcontextchangedEvent)
995         || hasEventListeners(eventNames().webglcontextlostEvent)
996         || hasEventListeners(eventNames().webglcontextrestoredEvent);
997 #endif
998 }
999
1000 }