HTMLCanvasElement.cpp [plain text]
#include "config.h"
#include "HTMLCanvasElement.h"
#include "Blob.h"
#include "BlobCallback.h"
#include "CSSCanvasValue.h"
#include "CanvasGradient.h"
#include "CanvasPattern.h"
#include "CanvasRenderingContext2D.h"
#include "Document.h"
#include "ExceptionCode.h"
#include "Frame.h"
#include "FrameLoaderClient.h"
#include "GPUBasedCanvasRenderingContext.h"
#include "GeometryUtilities.h"
#include "GraphicsContext.h"
#include "HTMLNames.h"
#include "HTMLParserIdioms.h"
#include "ImageData.h"
#include "InspectorInstrumentation.h"
#include "MIMETypeRegistry.h"
#include "RenderElement.h"
#include "RenderHTMLCanvas.h"
#include "RuntimeEnabledFeatures.h"
#include "ScriptController.h"
#include "Settings.h"
#include <math.h>
#include <runtime/JSCInlines.h>
#include <runtime/JSLock.h>
#include <wtf/RAMSize.h>
#include <wtf/text/StringBuilder.h>
#if ENABLE(MEDIA_STREAM)
#include "CanvasCaptureMediaStreamTrack.h"
#include "MediaStream.h"
#endif
#if ENABLE(WEBGL)
#include "WebGLContextAttributes.h"
#include "WebGLRenderingContextBase.h"
#endif
#if ENABLE(WEBGPU)
#include "WebGPURenderingContext.h"
#endif
#if PLATFORM(COCOA)
#include "MediaSampleAVFObjC.h"
#include "CoreMediaSoftLink.h"
#endif
namespace WebCore {
using namespace HTMLNames;
const int defaultWidth = 300;
const int defaultHeight = 150;
#if PLATFORM(IOS)
const unsigned maxCanvasArea = 4096 * 4096;
#else
const unsigned maxCanvasArea = 16384 * 16384;
#endif
#if USE(CG)
const InterpolationQuality defaultInterpolationQuality = InterpolationLow;
#else
const InterpolationQuality defaultInterpolationQuality = InterpolationDefault;
#endif
static size_t activePixelMemory = 0;
HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document& document)
: HTMLElement(tagName, document)
, m_size(defaultWidth, defaultHeight)
{
ASSERT(hasTagName(canvasTag));
}
Ref<HTMLCanvasElement> HTMLCanvasElement::create(Document& document)
{
return adoptRef(*new HTMLCanvasElement(canvasTag, document));
}
Ref<HTMLCanvasElement> HTMLCanvasElement::create(const QualifiedName& tagName, Document& document)
{
return adoptRef(*new HTMLCanvasElement(tagName, document));
}
static void removeFromActivePixelMemory(size_t pixelsReleased)
{
if (!pixelsReleased)
return;
if (pixelsReleased < activePixelMemory)
activePixelMemory -= pixelsReleased;
else
activePixelMemory = 0;
}
HTMLCanvasElement::~HTMLCanvasElement()
{
for (auto& observer : m_observers)
observer->canvasDestroyed(*this);
m_context = nullptr;
releaseImageBufferAndContext();
}
void HTMLCanvasElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == widthAttr || name == heightAttr)
reset();
HTMLElement::parseAttribute(name, value);
}
RenderPtr<RenderElement> HTMLCanvasElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition& insertionPosition)
{
Frame* frame = document().frame();
if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript))
return createRenderer<RenderHTMLCanvas>(*this, WTFMove(style));
return HTMLElement::createElementRenderer(WTFMove(style), insertionPosition);
}
bool HTMLCanvasElement::canContainRangeEndPoint() const
{
return false;
}
bool HTMLCanvasElement::canStartSelection() const
{
return false;
}
void HTMLCanvasElement::addObserver(CanvasObserver& observer)
{
m_observers.add(&observer);
if (is<CSSCanvasValue::CanvasObserverProxy>(observer))
InspectorInstrumentation::didChangeCSSCanvasClientNodes(*this);
}
void HTMLCanvasElement::removeObserver(CanvasObserver& observer)
{
m_observers.remove(&observer);
if (is<CSSCanvasValue::CanvasObserverProxy>(observer))
InspectorInstrumentation::didChangeCSSCanvasClientNodes(*this);
}
HashSet<Element*> HTMLCanvasElement::cssCanvasClients() const
{
HashSet<Element*> cssCanvasClients;
for (auto& observer : m_observers) {
if (!is<CSSCanvasValue::CanvasObserverProxy>(observer))
continue;
auto clients = downcast<CSSCanvasValue::CanvasObserverProxy>(observer)->ownerValue().clients();
for (auto& entry : clients) {
if (Element* element = entry.key->element())
cssCanvasClients.add(element);
}
}
return cssCanvasClients;
}
void HTMLCanvasElement::setHeight(unsigned value)
{
setAttributeWithoutSynchronization(heightAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, defaultHeight)));
}
void HTMLCanvasElement::setWidth(unsigned value)
{
setAttributeWithoutSynchronization(widthAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, defaultWidth)));
}
static inline size_t maxActivePixelMemory()
{
static size_t maxPixelMemory;
static std::once_flag onceFlag;
std::call_once(onceFlag, [] {
maxPixelMemory = std::max(ramSize() / 4, 2151 * MB);
});
return maxPixelMemory;
}
CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type)
{
if (HTMLCanvasElement::is2dType(type))
return getContext2d(type);
#if ENABLE(WEBGPU)
if (HTMLCanvasElement::isWebGPUType(type) && RuntimeEnabledFeatures::sharedFeatures().webGPUEnabled())
return getContextWebGPU(type);
#endif
#if ENABLE(WEBGL)
if (HTMLCanvasElement::is3dType(type))
return getContextWebGL(type);
#endif
return nullptr;
}
bool HTMLCanvasElement::is2dType(const String& type)
{
return type == "2d";
}
CanvasRenderingContext* HTMLCanvasElement::getContext2d(const String& type)
{
ASSERT_UNUSED(HTMLCanvasElement::is2dType(type), type);
if (m_context && !m_context->is2d())
return nullptr;
if (!m_context) {
bool usesDashboardCompatibilityMode = false;
#if ENABLE(DASHBOARD_SUPPORT)
usesDashboardCompatibilityMode = document().settings().usesDashboardBackwardCompatibilityMode();
#endif
size_t requestedPixelMemory = 4 * width() * height();
if (activePixelMemory + requestedPixelMemory > maxActivePixelMemory()) {
StringBuilder stringBuilder;
stringBuilder.appendLiteral("Total canvas memory use exceeds the maximum limit (");
stringBuilder.appendNumber(maxActivePixelMemory() / 1024 / 1024);
stringBuilder.appendLiteral(" MB).");
document().addConsoleMessage(MessageSource::JS, MessageLevel::Warning, stringBuilder.toString());
return nullptr;
}
m_context = std::make_unique<CanvasRenderingContext2D>(*this, document().inQuirksMode(), usesDashboardCompatibilityMode);
downcast<CanvasRenderingContext2D>(*m_context).setUsesDisplayListDrawing(m_usesDisplayListDrawing);
downcast<CanvasRenderingContext2D>(*m_context).setTracksDisplayListReplay(m_tracksDisplayListReplay);
InspectorInstrumentation::didCreateCanvasRenderingContext(*this);
#if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
invalidateStyleAndLayerComposition();
#endif
}
return m_context.get();
}
#if ENABLE(WEBGL)
static bool requiresAcceleratedCompositingForWebGL()
{
#if PLATFORM(GTK)
return false;
#else
return true;
#endif
}
static bool shouldEnableWebGL(const Settings& settings)
{
if (!settings.webGLEnabled())
return false;
if (!requiresAcceleratedCompositingForWebGL())
return true;
return settings.acceleratedCompositingEnabled();
}
bool HTMLCanvasElement::is3dType(const String& type)
{
return type == "webgl" || type == "experimental-webgl"
#if ENABLE(WEBGL2)
|| type == "webgl2"
#endif
|| type == "webkit-3d";
}
CanvasRenderingContext* HTMLCanvasElement::getContextWebGL(const String& type, WebGLContextAttributes&& attrs)
{
ASSERT(HTMLCanvasElement::is3dType(type));
if (!shouldEnableWebGL(document().settings()))
return nullptr;
if (m_context && !m_context->isWebGL())
return nullptr;
if (!m_context) {
m_context = WebGLRenderingContextBase::create(*this, attrs, type);
if (m_context) {
invalidateStyleAndLayerComposition();
InspectorInstrumentation::didCreateCanvasRenderingContext(*this);
}
}
return m_context.get();
}
#endif
#if ENABLE(WEBGPU)
bool HTMLCanvasElement::isWebGPUType(const String& type)
{
return type == "webgpu";
}
CanvasRenderingContext* HTMLCanvasElement::getContextWebGPU(const String& type)
{
ASSERT_UNUSED(type, HTMLCanvasElement::isWebGPUType(type));
if (!RuntimeEnabledFeatures::sharedFeatures().webGPUEnabled())
return nullptr;
if (m_context && !m_context->isWebGPU())
return nullptr;
if (!m_context) {
m_context = WebGPURenderingContext::create(*this);
if (m_context) {
invalidateStyleAndLayerComposition();
InspectorInstrumentation::didCreateCanvasRenderingContext(*this);
}
}
return m_context.get();
}
#endif
void HTMLCanvasElement::didDraw(const FloatRect& rect)
{
clearCopiedImage();
FloatRect dirtyRect = rect;
if (RenderBox* ro = renderBox()) {
FloatRect destRect = ro->contentBoxRect();
if (drawingContext() && drawingContext()->shouldAntialias())
dirtyRect.inflate(1);
FloatRect r = mapRect(dirtyRect, FloatRect(0, 0, size().width(), size().height()), destRect);
r.intersect(destRect);
if (!r.isEmpty() && !m_dirtyRect.contains(r)) {
m_dirtyRect.unite(r);
ro->repaintRectangle(enclosingIntRect(m_dirtyRect));
}
}
notifyObserversCanvasChanged(dirtyRect);
}
void HTMLCanvasElement::notifyObserversCanvasChanged(const FloatRect& rect)
{
for (auto& observer : m_observers)
observer->canvasChanged(*this, rect);
}
void HTMLCanvasElement::reset()
{
if (m_ignoreReset)
return;
bool hadImageBuffer = hasCreatedImageBuffer();
int w = limitToOnlyHTMLNonNegative(attributeWithoutSynchronization(widthAttr), defaultWidth);
int h = limitToOnlyHTMLNonNegative(attributeWithoutSynchronization(heightAttr), defaultHeight);
if (m_contextStateSaver) {
m_contextStateSaver->restore();
m_contextStateSaver->save();
}
if (is<CanvasRenderingContext2D>(m_context.get()))
downcast<CanvasRenderingContext2D>(*m_context).reset();
IntSize oldSize = size();
IntSize newSize(w, h);
if (m_hasCreatedImageBuffer && oldSize == newSize && m_context && m_context->is2d()) {
if (!m_didClearImageBuffer)
clearImageBuffer();
return;
}
setSurfaceSize(newSize);
if (isGPUBased() && oldSize != size())
downcast<GPUBasedCanvasRenderingContext>(*m_context).reshape(width(), height());
auto renderer = this->renderer();
if (is<RenderHTMLCanvas>(renderer)) {
auto& canvasRenderer = downcast<RenderHTMLCanvas>(*renderer);
if (oldSize != size()) {
canvasRenderer.canvasSizeChanged();
if (canvasRenderer.hasAcceleratedCompositing())
canvasRenderer.contentChanged(CanvasChanged);
}
if (hadImageBuffer)
canvasRenderer.repaint();
}
for (auto& observer : m_observers)
observer->canvasResized(*this);
}
bool HTMLCanvasElement::paintsIntoCanvasBuffer() const
{
ASSERT(m_context);
#if USE(IOSURFACE_CANVAS_BACKING_STORE)
if (m_context->is2d())
return true;
#endif
if (!m_context->isAccelerated())
return true;
if (renderBox() && renderBox()->hasAcceleratedCompositing())
return false;
return true;
}
void HTMLCanvasElement::paint(GraphicsContext& context, const LayoutRect& r)
{
m_dirtyRect = FloatRect();
if (context.paintingDisabled())
return;
if (m_context) {
if (!paintsIntoCanvasBuffer() && !document().printing())
return;
m_context->paintRenderingResultsToCanvas();
}
if (hasCreatedImageBuffer()) {
ImageBuffer* imageBuffer = buffer();
if (imageBuffer) {
if (m_presentedImage) {
ImageOrientationDescription orientationDescription;
#if ENABLE(CSS_IMAGE_ORIENTATION)
orientationDescription.setImageOrientationEnum(renderer()->style().imageOrientation());
#endif
context.drawImage(*m_presentedImage, snappedIntRect(r), ImagePaintingOptions(orientationDescription));
} else
context.drawImageBuffer(*imageBuffer, snappedIntRect(r));
}
}
if (isGPUBased())
downcast<GPUBasedCanvasRenderingContext>(*m_context).markLayerComposited();
}
bool HTMLCanvasElement::isGPUBased() const
{
return m_context && m_context->isGPUBased();
}
void HTMLCanvasElement::makeRenderingResultsAvailable()
{
if (m_context)
m_context->paintRenderingResultsToCanvas();
}
void HTMLCanvasElement::makePresentationCopy()
{
if (!m_presentedImage) {
m_presentedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
}
}
void HTMLCanvasElement::clearPresentationCopy()
{
m_presentedImage = nullptr;
}
void HTMLCanvasElement::releaseImageBufferAndContext()
{
m_contextStateSaver = nullptr;
setImageBuffer(nullptr);
}
void HTMLCanvasElement::setSurfaceSize(const IntSize& size)
{
m_size = size;
m_hasCreatedImageBuffer = false;
releaseImageBufferAndContext();
clearCopiedImage();
}
String HTMLCanvasElement::toEncodingMimeType(const String& mimeType)
{
if (!MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType))
return ASCIILiteral("image/png");
return mimeType.convertToASCIILowercase();
}
ExceptionOr<String> HTMLCanvasElement::toDataURL(const String& mimeType, std::optional<double> quality)
{
if (!m_originClean)
return Exception { SECURITY_ERR };
if (m_size.isEmpty() || !buffer())
return String { ASCIILiteral { "data:," } };
String encodingMIMEType = toEncodingMimeType(mimeType);
#if USE(CG)
if (auto imageData = getImageData())
return dataURL(*imageData, encodingMIMEType, quality);
#endif
makeRenderingResultsAvailable();
return buffer()->toDataURL(encodingMIMEType, quality);
}
ExceptionOr<void> HTMLCanvasElement::toBlob(ScriptExecutionContext& context, Ref<BlobCallback>&& callback, const String& mimeType, JSC::JSValue qualityValue)
{
if (!m_originClean)
return Exception { SECURITY_ERR };
if (m_size.isEmpty() || !buffer()) {
callback->scheduleCallback(context, nullptr);
return { };
}
String encodingMIMEType = toEncodingMimeType(mimeType);
std::optional<double> quality;
if (qualityValue.isNumber())
quality = qualityValue.toNumber(context.execState());
#if USE(CG)
if (auto imageData = getImageData()) {
RefPtr<Blob> blob;
Vector<uint8_t> blobData = data(*imageData, encodingMIMEType, quality);
if (!blobData.isEmpty())
blob = Blob::create(WTFMove(blobData), encodingMIMEType);
callback->scheduleCallback(context, WTFMove(blob));
return { };
}
#endif
makeRenderingResultsAvailable();
RefPtr<Blob> blob;
Vector<uint8_t> blobData = buffer()->toData(encodingMIMEType, quality);
if (!blobData.isEmpty())
blob = Blob::create(WTFMove(blobData), encodingMIMEType);
callback->scheduleCallback(context, WTFMove(blob));
return { };
}
RefPtr<ImageData> HTMLCanvasElement::getImageData()
{
#if ENABLE(WEBGL)
if (!m_context || !m_context->isWebGL())
return nullptr;
WebGLRenderingContextBase* ctx = static_cast<WebGLRenderingContextBase*>(m_context.get());
return ctx->paintRenderingResultsToImageData();
#else
return nullptr;
#endif
}
#if ENABLE(MEDIA_STREAM)
RefPtr<MediaSample> HTMLCanvasElement::toMediaSample()
{
auto* imageBuffer = buffer();
if (!imageBuffer)
return nullptr;
#if PLATFORM(COCOA)
makeRenderingResultsAvailable();
return MediaSampleAVFObjC::createImageSample(imageBuffer->toBGRAData(), width(), height());
#else
return nullptr;
#endif
}
ExceptionOr<Ref<MediaStream>> HTMLCanvasElement::captureStream(ScriptExecutionContext& context, std::optional<double>&& frameRequestRate)
{
if (!originClean())
return Exception(SECURITY_ERR, ASCIILiteral("Canvas is tainted"));
if (frameRequestRate && frameRequestRate.value() < 0)
return Exception(NOT_SUPPORTED_ERR, ASCIILiteral("frameRequestRate is negative"));
auto track = CanvasCaptureMediaStreamTrack::create(context, *this, WTFMove(frameRequestRate));
auto stream = MediaStream::create(context);
stream->addTrack(track);
return WTFMove(stream);
}
#endif
SecurityOrigin* HTMLCanvasElement::securityOrigin() const
{
return &document().securityOrigin();
}
bool HTMLCanvasElement::shouldAccelerate(const IntSize& size) const
{
auto& settings = document().settings();
auto area = size.area<RecordOverflow>();
if (area.hasOverflowed())
return false;
if (area > settings.maximumAccelerated2dCanvasSize())
return false;
#if USE(IOSURFACE_CANVAS_BACKING_STORE)
return settings.canvasUsesAcceleratedDrawing();
#elif ENABLE(ACCELERATED_2D_CANVAS)
if (m_context && !m_context->is2d())
return false;
if (!settings.accelerated2dCanvasEnabled())
return false;
if (area < settings.minimumAccelerated2dCanvasSize())
return false;
return true;
#else
UNUSED_PARAM(size);
return false;
#endif
}
size_t HTMLCanvasElement::memoryCost() const
{
auto locker = holdLock(m_imageBufferAssignmentLock);
if (!m_imageBuffer)
return 0;
return m_imageBuffer->memoryCost();
}
size_t HTMLCanvasElement::externalMemoryCost() const
{
auto locker = holdLock(m_imageBufferAssignmentLock);
if (!m_imageBuffer)
return 0;
return m_imageBuffer->externalMemoryCost();
}
void HTMLCanvasElement::setUsesDisplayListDrawing(bool usesDisplayListDrawing)
{
if (usesDisplayListDrawing == m_usesDisplayListDrawing)
return;
m_usesDisplayListDrawing = usesDisplayListDrawing;
if (is<CanvasRenderingContext2D>(m_context.get()))
downcast<CanvasRenderingContext2D>(*m_context).setUsesDisplayListDrawing(m_usesDisplayListDrawing);
}
void HTMLCanvasElement::setTracksDisplayListReplay(bool tracksDisplayListReplay)
{
if (tracksDisplayListReplay == m_tracksDisplayListReplay)
return;
m_tracksDisplayListReplay = tracksDisplayListReplay;
if (is<CanvasRenderingContext2D>(m_context.get()))
downcast<CanvasRenderingContext2D>(*m_context).setTracksDisplayListReplay(m_tracksDisplayListReplay);
}
String HTMLCanvasElement::displayListAsText(DisplayList::AsTextFlags flags) const
{
if (is<CanvasRenderingContext2D>(m_context.get()))
return downcast<CanvasRenderingContext2D>(*m_context).displayListAsText(flags);
return String();
}
String HTMLCanvasElement::replayDisplayListAsText(DisplayList::AsTextFlags flags) const
{
if (is<CanvasRenderingContext2D>(m_context.get()))
return downcast<CanvasRenderingContext2D>(*m_context).replayDisplayListAsText(flags);
return String();
}
void HTMLCanvasElement::createImageBuffer() const
{
ASSERT(!m_imageBuffer);
m_hasCreatedImageBuffer = true;
m_didClearImageBuffer = true;
if (float(width()) * height() > maxCanvasArea) {
StringBuilder stringBuilder;
stringBuilder.appendLiteral("Canvas area exceeds the maximum limit (width * height > ");
stringBuilder.appendNumber(maxCanvasArea);
stringBuilder.appendLiteral(").");
document().addConsoleMessage(MessageSource::JS, MessageLevel::Warning, stringBuilder.toString());
return;
}
size_t requestedPixelMemory = 4 * width() * height();
if (activePixelMemory + requestedPixelMemory > maxActivePixelMemory()) {
StringBuilder stringBuilder;
stringBuilder.appendLiteral("Total canvas memory use exceeds the maximum limit (");
stringBuilder.appendNumber(maxActivePixelMemory() / 1024 / 1024);
stringBuilder.appendLiteral(" MB).");
document().addConsoleMessage(MessageSource::JS, MessageLevel::Warning, stringBuilder.toString());
return;
}
if (!width() || !height())
return;
RenderingMode renderingMode = shouldAccelerate(size()) ? Accelerated : Unaccelerated;
setImageBuffer(ImageBuffer::create(size(), renderingMode));
if (!m_imageBuffer)
return;
m_imageBuffer->context().setShadowsIgnoreTransforms(true);
m_imageBuffer->context().setImageInterpolationQuality(defaultInterpolationQuality);
m_imageBuffer->context().setStrokeThickness(1);
m_contextStateSaver = std::make_unique<GraphicsContextStateSaver>(m_imageBuffer->context());
JSC::JSLockHolder lock(scriptExecutionContext()->vm());
scriptExecutionContext()->vm().heap.reportExtraMemoryAllocated(memoryCost());
#if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
if (m_context && m_context->is2d())
const_cast<HTMLCanvasElement*>(this)->invalidateStyleAndLayerComposition();
#endif
}
void HTMLCanvasElement::setImageBuffer(std::unique_ptr<ImageBuffer> buffer) const
{
size_t previousMemoryCost = memoryCost();
removeFromActivePixelMemory(previousMemoryCost);
{
auto locker = holdLock(m_imageBufferAssignmentLock);
m_imageBuffer = WTFMove(buffer);
}
size_t currentMemoryCost = memoryCost();
activePixelMemory += currentMemoryCost;
if (m_imageBuffer && previousMemoryCost != currentMemoryCost)
InspectorInstrumentation::didChangeCanvasMemory(const_cast<HTMLCanvasElement&>(*this));
}
GraphicsContext* HTMLCanvasElement::drawingContext() const
{
return buffer() ? &m_imageBuffer->context() : nullptr;
}
GraphicsContext* HTMLCanvasElement::existingDrawingContext() const
{
if (!m_hasCreatedImageBuffer)
return nullptr;
return drawingContext();
}
ImageBuffer* HTMLCanvasElement::buffer() const
{
if (!m_hasCreatedImageBuffer)
createImageBuffer();
return m_imageBuffer.get();
}
Image* HTMLCanvasElement::copiedImage() const
{
if (!m_copiedImage && buffer()) {
if (m_context)
m_context->paintRenderingResultsToCanvas();
m_copiedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
}
return m_copiedImage.get();
}
void HTMLCanvasElement::clearImageBuffer() const
{
ASSERT(m_hasCreatedImageBuffer);
ASSERT(!m_didClearImageBuffer);
ASSERT(m_context);
m_didClearImageBuffer = true;
if (is<CanvasRenderingContext2D>(*m_context)) {
downcast<CanvasRenderingContext2D>(*m_context).clearRect(0, 0, width(), height());
}
}
void HTMLCanvasElement::clearCopiedImage()
{
m_copiedImage = nullptr;
m_didClearImageBuffer = false;
}
AffineTransform HTMLCanvasElement::baseTransform() const
{
ASSERT(m_hasCreatedImageBuffer);
return m_imageBuffer->baseTransform();
}
}