void HTMLCanvasElement::discardImageBuffer()
{
m_contextStateSaver.clear(); // uses context owned by m_imageBuffer
m_imageBuffer.clear();
resetDirtyRect();
updateExternallyAllocatedMemory();
}
void HTMLCanvasElement::clearCopiedImage()
{
if (m_copiedImage) {
m_copiedImage.clear();
updateExternallyAllocatedMemory();
}
m_didClearImageBuffer = false;
}
void HTMLCanvasElement::makePresentationCopy()
{
if (!m_presentedImage) {
// The buffer contains the last presented data, so save a copy of it.
m_presentedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
updateExternallyAllocatedMemory();
}
}
void HTMLCanvasElement::createImageBufferInternal()
{
ASSERT(!m_imageBuffer);
ASSERT(!m_contextStateSaver);
m_didFailToCreateImageBuffer = true;
m_didClearImageBuffer = true;
IntSize deviceSize = size();
if (deviceSize.width() * deviceSize.height() > MaxCanvasArea)
return;
if (deviceSize.width() > MaxSkiaDim || deviceSize.height() > MaxSkiaDim)
return;
if (!deviceSize.width() || !deviceSize.height())
return;
int msaaSampleCount;
OwnPtr<ImageBufferSurface> surface = createImageBufferSurface(deviceSize, &msaaSampleCount);
if (!surface->isValid())
return;
m_imageBuffer = ImageBuffer::create(surface.release());
m_imageBuffer->setClient(this);
m_didFailToCreateImageBuffer = false;
updateExternallyAllocatedMemory();
if (is3D()) {
// Early out for WebGL canvases
return;
}
m_imageBuffer->setClient(this);
m_imageBuffer->context()->setShouldClampToSourceRect(false);
m_imageBuffer->context()->disableAntialiasingOptimizationForHairlineImages();
m_imageBuffer->context()->setImageInterpolationQuality(CanvasDefaultInterpolationQuality);
// Enabling MSAA overrides a request to disable antialiasing. This is true regardless of whether the
// rendering mode is accelerated or not. For consistency, we don't want to apply AA in accelerated
// canvases but not in unaccelerated canvases.
if (!msaaSampleCount && document().settings() && !document().settings()->antialiased2dCanvasEnabled())
m_imageBuffer->context()->setShouldAntialias(false);
// GraphicsContext's defaults don't always agree with the 2d canvas spec.
// See CanvasRenderingContext2D::State::State() for more information.
m_imageBuffer->context()->setMiterLimit(10);
m_imageBuffer->context()->setStrokeThickness(1);
#if ENABLE(ASSERT)
m_imageBuffer->context()->disableDestructionChecks(); // 2D canvas is allowed to leave context in an unfinalized state.
#endif
m_contextStateSaver = adoptPtr(new GraphicsContextStateSaver(*m_imageBuffer->context()));
if (m_context)
setNeedsCompositingUpdate();
}
Image* HTMLCanvasElement::copiedImage() const
{
if (!m_copiedImage && buffer()) {
if (m_context && m_context->is3d()) {
toWebGLRenderingContext(m_context.get())->setSavingImage(true);
m_context->paintRenderingResultsToCanvas();
toWebGLRenderingContext(m_context.get())->setSavingImage(false);
}
m_copiedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
updateExternallyAllocatedMemory();
}
return m_copiedImage.get();
}
CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)
{
// A Canvas can either be "2D" or "webgl" but never both. If you request a 2D canvas and the existing
// context is already 2D, just return that. If the existing context is WebGL, then destroy it
// before creating a new 2D context. Vice versa when requesting a WebGL canvas. Requesting a
// context with any other type string will destroy any existing context.
enum ContextType {
// Do not change assigned numbers of existing items: add new features to the end of the list.
Context2d = 0,
ContextExperimentalWebgl = 2,
ContextWebgl = 3,
ContextTypeCount,
};
// FIXME - The code depends on the context not going away once created, to prevent JS from
// seeing a dangling pointer. So for now we will disallow the context from being changed
// once it is created.
if (type == "2d") {
if (m_context && !m_context->is2d())
return 0;
if (!m_context) {
blink::Platform::current()->histogramEnumeration("Canvas.ContextType", Context2d, ContextTypeCount);
m_context = CanvasRenderingContext2D::create(this, static_cast<Canvas2DContextAttributes*>(attrs), document().inQuirksMode());
setNeedsCompositingUpdate();
}
return m_context.get();
}
// Accept the the provisional "experimental-webgl" or official "webgl" context ID.
if (type == "webgl" || type == "experimental-webgl") {
ContextType contextType = (type == "webgl") ? ContextWebgl : ContextExperimentalWebgl;
if (!m_context) {
blink::Platform::current()->histogramEnumeration("Canvas.ContextType", contextType, ContextTypeCount);
m_context = WebGLRenderingContext::create(this, static_cast<WebGLContextAttributes*>(attrs));
setNeedsCompositingUpdate();
updateExternallyAllocatedMemory();
} else if (!m_context->is3d()) {
dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Canvas has an existing, non-WebGL context"));
return 0;
}
return m_context.get();
}
return 0;
}
void HTMLCanvasElement::clearPresentationCopy()
{
m_presentedImage.clear();
updateExternallyAllocatedMemory();
}
