Add some plumbing for the color management of canvases

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 555 matching lines @@
     ContextProviderCreationInfo creationInfo;
     creationInfo.contextAttributes = contextAttributes;
     creationInfo.glInfo = glInfo;
     creationInfo.scriptState = scriptState;
     WebTaskRunner* taskRunner = Platform::current()->mainThread()->getWebTaskRunner();
     taskRunner->postTask(BLINK_FROM_HERE, crossThreadBind(&createContextProviderOnMainThread, crossThreadUnretained(&creationInfo), crossThreadUnretained(&waitableEvent)));
     waitableEvent.wait();
     return std::move(creationInfo.createdContextProvider);
 }
 
-std::unique_ptr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createContextProviderInternal(HTMLCanvasElement* canvas, ScriptState* scriptState, WebGLContextAttributes attributes, unsigned webGLVersion)
+std::unique_ptr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createContextProviderInternal(HTMLCanvasElement* canvas, ScriptState* scriptState, const CanvasContextCreationAttributes& attributes, unsigned webGLVersion)
 {
     // Exactly one of these must be provided.
     DCHECK_EQ(!canvas, !!scriptState);
     // The canvas is only given on the main thread.
     DCHECK(!canvas || isMainThread());
 
     Platform::ContextAttributes contextAttributes = toPlatformContextAttributes(attributes, webGLVersion);
     Platform::GraphicsInfo glInfo;
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider;
     if (isMainThread()) {
@@ skipping 17 matching lines @@
     }
     gpu::gles2::GLES2Interface* gl = contextProvider->contextGL();
     if (!String(gl->GetString(GL_EXTENSIONS)).contains("GL_OES_packed_depth_stencil")) {
         if (canvas)
             canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "OES_packed_depth_stencil support is required."));
         return nullptr;
     }
     return contextProvider;
 }
 
-std::unique_ptr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProvider(HTMLCanvasElement* canvas, WebGLContextAttributes attributes, unsigned webGLVersion)
+std::unique_ptr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProvider(HTMLCanvasElement* canvas, const CanvasContextCreationAttributes& attributes, unsigned webGLVersion)
 {
     Document& document = canvas->document();
     LocalFrame* frame = document.frame();
     if (!frame) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
         return nullptr;
     }
     Settings* settings = frame->settings();
 
     // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in
     // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.
     if (!frame->loader().client()->allowWebGL(settings && settings->webGLEnabled())) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
         return nullptr;
     }
 
     return createContextProviderInternal(canvas, nullptr, attributes, webGLVersion);
 }
 
-std::unique_ptr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProvider(ScriptState* scriptState, WebGLContextAttributes attributes, unsigned webGLVersion)
+std::unique_ptr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProvider(ScriptState* scriptState, const CanvasContextCreationAttributes& attributes, unsigned webGLVersion)
 {
     return createContextProviderInternal(nullptr, scriptState, attributes, webGLVersion);
 }
 
 void WebGLRenderingContextBase::forceNextWebGLContextCreationToFail()
 {
     shouldFailContextCreationForTesting = true;
 }
 
 ImageBitmap* WebGLRenderingContextBase::transferToImageBitmapBase()
@@ skipping 248 matching lines @@
         return true;
     default:
         return false;
     }
 }
 
 } // namespace
 
 WebGLRenderingContextBase::WebGLRenderingContextBase(OffscreenCanvas* passedOffscreenCanvas,
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
-    const WebGLContextAttributes& requestedAttributes, unsigned version)
+    const CanvasContextCreationAttributes& requestedAttributes, unsigned version)
     : WebGLRenderingContextBase(nullptr, passedOffscreenCanvas, std::move(contextProvider), requestedAttributes, version)
 { }
 
 WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas,
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
-    const WebGLContextAttributes& requestedAttributes, unsigned version)
+    const CanvasContextCreationAttributes& requestedAttributes, unsigned version)
     : WebGLRenderingContextBase(passedCanvas, nullptr, std::move(contextProvider), requestedAttributes, version)
 { }
 
 WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas,
     OffscreenCanvas* passedOffscreenCanvas, std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
-    const WebGLContextAttributes& requestedAttributes, unsigned version)
-    : CanvasRenderingContext(passedCanvas, passedOffscreenCanvas)
+    const CanvasContextCreationAttributes& requestedAttributes, unsigned version)
+    : CanvasRenderingContext(passedCanvas, passedOffscreenCanvas, requestedAttributes)
     , m_isHidden(false)
     , m_contextLostMode(NotLostContext)
     , m_autoRecoveryMethod(Manual)
     , m_dispatchContextLostEventTimer(this, &WebGLRenderingContextBase::dispatchContextLostEvent)
     , m_restoreAllowed(false)
     , m_restoreTimer(this, &WebGLRenderingContextBase::maybeRestoreContext)
     , m_preservedDefaultVAOObjectWrapper(false)
     , m_generatedImageCache(4)
-    , m_requestedAttributes(requestedAttributes)
     , m_synthesizedErrorsToConsole(true)
     , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)
     , m_onePlusMaxNonDefaultTextureUnit(0)
     , m_isWebGL2FormatsTypesAdded(false)
     , m_isWebGL2InternalFormatsCopyTexImageAdded(false)
     , m_isOESTextureFloatFormatsTypesAdded(false)
     , m_isOESTextureHalfFloatFormatsTypesAdded(false)
     , m_isWebGLDepthTextureFormatsTypesAdded(false)
     , m_isEXTsRGBFormatsTypesAdded(false)
     , m_version(version)
@@ skipping 23 matching lines @@
     }
 
     ADD_VALUES_TO_SET(m_supportedInternalFormats, kSupportedInternalFormatsES2);
     ADD_VALUES_TO_SET(m_supportedInternalFormatsCopyTexImage, kSupportedInternalFormatsES2);
     ADD_VALUES_TO_SET(m_supportedFormats, kSupportedFormatsES2);
     ADD_VALUES_TO_SET(m_supportedTypes, kSupportedTypesES2);
 }
 
 PassRefPtr<DrawingBuffer> WebGLRenderingContextBase::createDrawingBuffer(std::unique_ptr<WebGraphicsContext3DProvider> contextProvider)
 {
-    bool premultipliedAlpha = m_requestedAttributes.premultipliedAlpha();
-    bool wantAlphaChannel = m_requestedAttributes.alpha();
-    bool wantDepthBuffer = m_requestedAttributes.depth();
-    bool wantStencilBuffer = m_requestedAttributes.stencil();
-    bool wantAntialiasing = m_requestedAttributes.antialias();
-    DrawingBuffer::PreserveDrawingBuffer preserve = m_requestedAttributes.preserveDrawingBuffer() ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
+    bool premultipliedAlpha = creationAttributes().premultipliedAlpha();
+    bool wantAlphaChannel = creationAttributes().alpha();
+    bool wantDepthBuffer = creationAttributes().depth();
+    bool wantStencilBuffer = creationAttributes().stencil();
+    bool wantAntialiasing = creationAttributes().antialias();
+    DrawingBuffer::PreserveDrawingBuffer preserve = creationAttributes().preserveDrawingBuffer() ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
     DrawingBuffer::WebGLVersion webGLVersion = DrawingBuffer::WebGL1;
     if (version() == 1) {
         webGLVersion = DrawingBuffer::WebGL1;
     } else if (version() == 2) {
         webGLVersion = DrawingBuffer::WebGL2;
     } else {
         NOTREACHED();
     }
     return DrawingBuffer::create(
         std::move(contextProvider),
@@ skipping 372 matching lines @@
         return false;
     }
 
     return true;
 }
 
 ImageData* WebGLRenderingContextBase::paintRenderingResultsToImageData(SourceDrawingBuffer sourceBuffer)
 {
     if (isContextLost())
         return nullptr;
-    if (m_requestedAttributes.premultipliedAlpha())
+    if (creationAttributes().premultipliedAlpha())
         return nullptr;
 
     clearIfComposited();
     drawingBuffer()->commit();
     ScopedFramebufferRestorer restorer(this);
     int width, height;
     WTF::ArrayBufferContents contents;
     if (!drawingBuffer()->paintRenderingResultsToImageData(width, height, sourceBuffer, contents))
         return nullptr;
     DOMArrayBuffer* imageDataPixels = DOMArrayBuffer::create(contents);
@@ skipping 1185 matching lines @@
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getBufferParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 }
 
 void WebGLRenderingContextBase::getContextAttributes(Nullable<WebGLContextAttributes>& result)
 {
     if (isContextLost())
         return;
-    result.set(m_requestedAttributes);
+    result.set(toWebGLContextAttributes(creationAttributes()));
     // Some requested attributes may not be honored, so we need to query the underlying
     // context/drawing buffer and adjust accordingly.
-    if (m_requestedAttributes.depth() && !drawingBuffer()->hasDepthBuffer())
+    if (creationAttributes().depth() && !drawingBuffer()->hasDepthBuffer())
         result.get().setDepth(false);
-    if (m_requestedAttributes.stencil() && !drawingBuffer()->hasStencilBuffer())
+    if (creationAttributes().stencil() && !drawingBuffer()->hasStencilBuffer())
         result.get().setStencil(false);
     result.get().setAntialias(drawingBuffer()->multisample());
 }
 
 GLenum WebGLRenderingContextBase::getError()
 {
     if (!m_lostContextErrors.isEmpty()) {
         GLenum error = m_lostContextErrors.first();
         m_lostContextErrors.remove(0);
         return error;
@@ skipping 181 matching lines @@
         return getBooleanArrayParameter(scriptState, pname);
     case GL_COMPRESSED_TEXTURE_FORMATS:
         return WebGLAny(scriptState, DOMUint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()));
     case GL_CULL_FACE:
         return getBooleanParameter(scriptState, pname);
     case GL_CULL_FACE_MODE:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_CURRENT_PROGRAM:
         return WebGLAny(scriptState, m_currentProgram.get());
     case GL_DEPTH_BITS:
-        if (!m_framebufferBinding && !m_requestedAttributes.depth())
+        if (!m_framebufferBinding && !creationAttributes().depth())
             return WebGLAny(scriptState, intZero);
         return getIntParameter(scriptState, pname);
     case GL_DEPTH_CLEAR_VALUE:
         return getFloatParameter(scriptState, pname);
     case GL_DEPTH_FUNC:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_DEPTH_RANGE:
         return getWebGLFloatArrayParameter(scriptState, pname);
     case GL_DEPTH_TEST:
         return getBooleanParameter(scriptState, pname);
@@ skipping 78 matching lines @@
         return getUnsignedIntParameter(scriptState, pname);
     case GL_STENCIL_BACK_PASS_DEPTH_PASS:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_STENCIL_BACK_REF:
         return getIntParameter(scriptState, pname);
     case GL_STENCIL_BACK_VALUE_MASK:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_STENCIL_BACK_WRITEMASK:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_STENCIL_BITS:
-        if (!m_framebufferBinding && !m_requestedAttributes.stencil())
+        if (!m_framebufferBinding && !creationAttributes().stencil())
             return WebGLAny(scriptState, intZero);
         return getIntParameter(scriptState, pname);
     case GL_STENCIL_CLEAR_VALUE:
         return getIntParameter(scriptState, pname);
     case GL_STENCIL_FAIL:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_STENCIL_FUNC:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_STENCIL_PASS_DEPTH_FAIL:
         return getUnsignedIntParameter(scriptState, pname);
@@ skipping 3262 matching lines @@
 
     if (!frame->loader().client()->allowWebGL(settings && settings->webGLEnabled()))
         return;
 
     // If the context was lost due to RealLostContext, we need to destroy the old DrawingBuffer before creating new DrawingBuffer to ensure resource budget enough.
     if (drawingBuffer()) {
         m_drawingBuffer->beginDestruction();
         m_drawingBuffer.clear();
     }
 
-    Platform::ContextAttributes attributes = toPlatformContextAttributes(m_requestedAttributes, version());
+    Platform::ContextAttributes attributes = toPlatformContextAttributes(creationAttributes(), version());
     Platform::GraphicsInfo glInfo;
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider = wrapUnique(Platform::current()->createOffscreenGraphicsContext3DProvider(
         attributes, canvas()->document().topDocument().url(), 0, &glInfo));
     RefPtr<DrawingBuffer> buffer;
     if (contextProvider && contextProvider->bindToCurrentThread()) {
         // Construct a new drawing buffer with the new GL context.
         buffer = createDrawingBuffer(std::move(contextProvider));
         // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is set to null.
     }
     if (!buffer) {
@@ skipping 322 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink