HTMLCanvasElement.cpp [plain text]
#include "config.h"
#include "HTMLCanvasElement.h"
#include "Attribute.h"
#include "CanvasGradient.h"
#include "CanvasPattern.h"
#include "CanvasRenderingContext2D.h"
#include "Chrome.h"
#include "ChromeClient.h"
#include "Document.h"
#include "ExceptionCode.h"
#include "Frame.h"
#include "FrameLoaderClient.h"
#include "GeometryUtilities.h"
#include "GraphicsContext.h"
#include "HTMLNames.h"
#include "ImageData.h"
#include "MIMETypeRegistry.h"
#include "Page.h"
#include "RenderHTMLCanvas.h"
#include "ScriptController.h"
#include "Settings.h"
#include <math.h>
#include <runtime/JSCInlines.h>
#include <runtime/JSLock.h>
#if ENABLE(WEBGL)
#include "WebGLContextAttributes.h"
#include "WebGLRenderingContext.h"
#endif
namespace WebCore {
using namespace HTMLNames;
static const int DefaultWidth = 300;
static const int DefaultHeight = 150;
static const float MaxCanvasArea = 16384 * 16384;
HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document& document)
: HTMLElement(tagName, document)
, m_size(DefaultWidth, DefaultHeight)
, m_rendererIsCanvas(false)
, m_ignoreReset(false)
, m_deviceScaleFactor(targetDeviceScaleFactor())
, m_originClean(true)
, m_hasCreatedImageBuffer(false)
, m_didClearImageBuffer(false)
{
ASSERT(hasTagName(canvasTag));
setHasCustomStyleResolveCallbacks();
}
PassRefPtr<HTMLCanvasElement> HTMLCanvasElement::create(Document& document)
{
return adoptRef(new HTMLCanvasElement(canvasTag, document));
}
PassRefPtr<HTMLCanvasElement> HTMLCanvasElement::create(const QualifiedName& tagName, Document& document)
{
return adoptRef(new HTMLCanvasElement(tagName, document));
}
HTMLCanvasElement::~HTMLCanvasElement()
{
for (auto it = m_observers.begin(), end = m_observers.end(); it != end; ++it)
(*it)->canvasDestroyed(*this);
m_context = nullptr; }
void HTMLCanvasElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == widthAttr || name == heightAttr)
reset();
HTMLElement::parseAttribute(name, value);
}
RenderPtr<RenderElement> HTMLCanvasElement::createElementRenderer(PassRef<RenderStyle> style)
{
Frame* frame = document().frame();
if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript)) {
m_rendererIsCanvas = true;
return createRenderer<RenderHTMLCanvas>(*this, WTF::move(style));
}
m_rendererIsCanvas = false;
return HTMLElement::createElementRenderer(WTF::move(style));
}
void HTMLCanvasElement::willAttachRenderers()
{
setIsInCanvasSubtree(true);
}
bool HTMLCanvasElement::canContainRangeEndPoint() const
{
return false;
}
bool HTMLCanvasElement::canStartSelection() const
{
return false;
}
void HTMLCanvasElement::addObserver(CanvasObserver& observer)
{
m_observers.add(&observer);
}
void HTMLCanvasElement::removeObserver(CanvasObserver& observer)
{
m_observers.remove(&observer);
}
void HTMLCanvasElement::setHeight(int value)
{
setIntegralAttribute(heightAttr, value);
}
void HTMLCanvasElement::setWidth(int value)
{
setIntegralAttribute(widthAttr, value);
}
#if ENABLE(WEBGL)
static bool requiresAcceleratedCompositingForWebGL()
{
#if PLATFORM(GTK) || PLATFORM(EFL)
return false;
#else
return true;
#endif
}
static bool shouldEnableWebGL(Settings* settings)
{
if (!settings)
return false;
if (!settings->webGLEnabled())
return false;
if (!requiresAcceleratedCompositingForWebGL())
return true;
return settings->acceleratedCompositingEnabled();
}
#endif
CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)
{
if (is2dType(type)) {
if (m_context && !m_context->is2d())
return nullptr;
if (!m_context) {
bool usesDashbardCompatibilityMode = false;
#if ENABLE(DASHBOARD_SUPPORT)
if (Settings* settings = document().settings())
usesDashbardCompatibilityMode = settings->usesDashboardBackwardCompatibilityMode();
#endif
m_context = std::make_unique<CanvasRenderingContext2D>(this, document().inQuirksMode(), usesDashbardCompatibilityMode);
#if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
setNeedsStyleRecalc(SyntheticStyleChange);
#endif
}
return m_context.get();
}
#if ENABLE(WEBGL)
if (shouldEnableWebGL(document().settings())) {
if (is3dType(type)) {
if (m_context && !m_context->is3d())
return nullptr;
if (!m_context) {
m_context = WebGLRenderingContext::create(this, static_cast<WebGLContextAttributes*>(attrs));
if (m_context) {
setNeedsStyleRecalc(SyntheticStyleChange);
}
}
return m_context.get();
}
}
#else
UNUSED_PARAM(attrs);
#endif
return nullptr;
}
bool HTMLCanvasElement::probablySupportsContext(const String& type, CanvasContextAttributes*)
{
if (is2dType(type))
return !m_context || m_context->is2d();
#if ENABLE(WEBGL)
if (shouldEnableWebGL(document().settings())) {
if (is3dType(type))
return !m_context || m_context->is3d();
}
#endif
return false;
}
bool HTMLCanvasElement::is2dType(const String& type)
{
return type == "2d";
}
#if ENABLE(WEBGL)
bool HTMLCanvasElement::is3dType(const String& type)
{
return type == "webgl" || type == "experimental-webgl" || type == "webkit-3d";
}
#endif
void HTMLCanvasElement::didDraw(const FloatRect& rect)
{
clearCopiedImage();
if (RenderBox* ro = renderBox()) {
FloatRect destRect = ro->contentBoxRect();
FloatRect r = mapRect(rect, FloatRect(0, 0, size().width(), size().height()), destRect);
r.intersect(destRect);
if (r.isEmpty() || m_dirtyRect.contains(r))
return;
m_dirtyRect.unite(r);
ro->repaintRectangle(enclosingIntRect(m_dirtyRect));
}
notifyObserversCanvasChanged(rect);
}
void HTMLCanvasElement::notifyObserversCanvasChanged(const FloatRect& rect)
{
for (auto it = m_observers.begin(), end = m_observers.end(); it != end; ++it)
(*it)->canvasChanged(*this, rect);
}
void HTMLCanvasElement::reset()
{
if (m_ignoreReset)
return;
bool ok;
bool hadImageBuffer = hasCreatedImageBuffer();
int w = getAttribute(widthAttr).toInt(&ok);
if (!ok || w < 0)
w = DefaultWidth;
int h = getAttribute(heightAttr).toInt(&ok);
if (!ok || h < 0)
h = DefaultHeight;
if (m_contextStateSaver) {
m_contextStateSaver->restore();
m_contextStateSaver->save();
}
if (m_context && m_context->is2d()) {
CanvasRenderingContext2D* context2D = static_cast<CanvasRenderingContext2D*>(m_context.get());
context2D->reset();
}
IntSize oldSize = size();
IntSize newSize(w, h);
float newDeviceScaleFactor = targetDeviceScaleFactor();
if (m_hasCreatedImageBuffer && oldSize == newSize && m_deviceScaleFactor == newDeviceScaleFactor && m_context && m_context->is2d()) {
if (!m_didClearImageBuffer)
clearImageBuffer();
return;
}
m_deviceScaleFactor = newDeviceScaleFactor;
setSurfaceSize(newSize);
#if ENABLE(WEBGL)
if (is3D() && oldSize != size())
static_cast<WebGLRenderingContext*>(m_context.get())->reshape(width(), height());
#endif
if (auto renderer = this->renderer()) {
if (m_rendererIsCanvas) {
if (oldSize != size()) {
toRenderHTMLCanvas(renderer)->canvasSizeChanged();
if (renderBox() && renderBox()->hasAcceleratedCompositing())
renderBox()->contentChanged(CanvasChanged);
}
if (hadImageBuffer)
renderer->repaint();
}
}
for (auto it = m_observers.begin(), end = m_observers.end(); it != end; ++it)
(*it)->canvasResized(*this);
}
float HTMLCanvasElement::targetDeviceScaleFactor() const
{
#if ENABLE(HIGH_DPI_CANVAS)
return document().frame() ? document().frame()->page()->deviceScaleFactor() : 1;
#else
return 1;
#endif
}
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, bool useLowQualityScale)
{
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.get(), ColorSpaceDeviceRGB, pixelSnappedIntRect(r), ImagePaintingOptions(orientationDescription, useLowQualityScale));
} else
context->drawImageBuffer(imageBuffer, ColorSpaceDeviceRGB, pixelSnappedIntRect(r), useLowQualityScale);
}
}
#if ENABLE(WEBGL)
if (is3D())
static_cast<WebGLRenderingContext*>(m_context.get())->markLayerComposited();
#endif
}
#if ENABLE(WEBGL)
bool HTMLCanvasElement::is3D() const
{
return m_context && m_context->is3d();
}
#endif
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.clear();
}
void HTMLCanvasElement::setSurfaceSize(const IntSize& size)
{
m_size = size;
m_hasCreatedImageBuffer = false;
m_contextStateSaver = nullptr;
m_imageBuffer.reset();
clearCopiedImage();
}
String HTMLCanvasElement::toEncodingMimeType(const String& mimeType)
{
String lowercaseMimeType = mimeType.lower();
if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(lowercaseMimeType))
lowercaseMimeType = "image/png";
return lowercaseMimeType;
}
String HTMLCanvasElement::toDataURL(const String& mimeType, const double* quality, ExceptionCode& ec)
{
if (!m_originClean) {
ec = SECURITY_ERR;
return String();
}
if (m_size.isEmpty() || !buffer())
return String("data:,");
String encodingMimeType = toEncodingMimeType(mimeType);
#if USE(CG)
RefPtr<ImageData> imageData = getImageData();
if (imageData)
return ImageDataToDataURL(*imageData, encodingMimeType, quality);
#endif
makeRenderingResultsAvailable();
return buffer()->toDataURL(encodingMimeType, quality);
}
PassRefPtr<ImageData> HTMLCanvasElement::getImageData()
{
#if ENABLE(WEBGL)
if (!is3D())
return nullptr;
WebGLRenderingContext* ctx = static_cast<WebGLRenderingContext*>(m_context.get());
return ctx->paintRenderingResultsToImageData();
#else
return nullptr;
#endif
}
FloatRect HTMLCanvasElement::convertLogicalToDevice(const FloatRect& logicalRect) const
{
FloatRect deviceRect(logicalRect);
deviceRect.scale(m_deviceScaleFactor);
float x = floorf(deviceRect.x());
float y = floorf(deviceRect.y());
float w = ceilf(deviceRect.maxX() - x);
float h = ceilf(deviceRect.maxY() - y);
deviceRect.setX(x);
deviceRect.setY(y);
deviceRect.setWidth(w);
deviceRect.setHeight(h);
return deviceRect;
}
FloatSize HTMLCanvasElement::convertLogicalToDevice(const FloatSize& logicalSize) const
{
float width = ceilf(logicalSize.width() * m_deviceScaleFactor);
float height = ceilf(logicalSize.height() * m_deviceScaleFactor);
return FloatSize(width, height);
}
FloatSize HTMLCanvasElement::convertDeviceToLogical(const FloatSize& deviceSize) const
{
float width = ceilf(deviceSize.width() / m_deviceScaleFactor);
float height = ceilf(deviceSize.height() / m_deviceScaleFactor);
return FloatSize(width, height);
}
SecurityOrigin* HTMLCanvasElement::securityOrigin() const
{
return document().securityOrigin();
}
bool HTMLCanvasElement::shouldAccelerate(const IntSize& size) const
{
#if USE(IOSURFACE_CANVAS_BACKING_STORE)
UNUSED_PARAM(size);
return document().settings() && document().settings()->canvasUsesAcceleratedDrawing();
#elif ENABLE(ACCELERATED_2D_CANVAS)
if (m_context && !m_context->is2d())
return false;
Settings* settings = document().settings();
if (!settings || !settings->accelerated2dCanvasEnabled())
return false;
if (size.width() * size.height() < settings->minimumAccelerated2dCanvasSize())
return false;
return true;
#else
UNUSED_PARAM(size);
return false;
#endif
}
void HTMLCanvasElement::createImageBuffer() const
{
ASSERT(!m_imageBuffer);
m_hasCreatedImageBuffer = true;
m_didClearImageBuffer = true;
FloatSize logicalSize = size();
FloatSize deviceSize = convertLogicalToDevice(logicalSize);
if (!deviceSize.isExpressibleAsIntSize())
return;
if (deviceSize.width() * deviceSize.height() > MaxCanvasArea)
return;
IntSize bufferSize(deviceSize.width(), deviceSize.height());
if (!bufferSize.width() || !bufferSize.height())
return;
RenderingMode renderingMode = shouldAccelerate(bufferSize) ? Accelerated : Unaccelerated;
m_imageBuffer = ImageBuffer::create(size(), m_deviceScaleFactor, ColorSpaceDeviceRGB, renderingMode);
if (!m_imageBuffer)
return;
m_imageBuffer->context()->setShadowsIgnoreTransforms(true);
m_imageBuffer->context()->setImageInterpolationQuality(DefaultInterpolationQuality);
if (document().settings() && !document().settings()->antialiased2dCanvasEnabled())
m_imageBuffer->context()->setShouldAntialias(false);
m_imageBuffer->context()->setStrokeThickness(1);
m_contextStateSaver = std::make_unique<GraphicsContextStateSaver>(*m_imageBuffer->context());
JSC::JSLockHolder lock(scriptExecutionContext()->vm());
size_t numBytes = 4 * m_imageBuffer->internalSize().width() * m_imageBuffer->internalSize().height();
scriptExecutionContext()->vm().heap.reportExtraMemoryCost(numBytes);
#if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
if (m_context && m_context->is2d())
const_cast<HTMLCanvasElement*>(this)->setNeedsStyleRecalc(SyntheticStyleChange);
#endif
}
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 (m_context->is2d()) {
CanvasRenderingContext2D* context2D = static_cast<CanvasRenderingContext2D*>(m_context.get());
context2D->clearRect(0, 0, width(), height());
}
}
void HTMLCanvasElement::clearCopiedImage()
{
m_copiedImage.clear();
m_didClearImageBuffer = false;
}
AffineTransform HTMLCanvasElement::baseTransform() const
{
ASSERT(m_hasCreatedImageBuffer);
FloatSize unscaledSize = size();
FloatSize deviceSize = convertLogicalToDevice(unscaledSize);
IntSize size(deviceSize.width(), deviceSize.height());
AffineTransform transform;
if (size.width() && size.height())
transform.scaleNonUniform(size.width() / unscaledSize.width(), size.height() / unscaledSize.height());
return m_imageBuffer->baseTransform() * transform;
}
}