Remove alpha/depth/stencil/antialias from WGC3D::Attributes.

third_party/WebKit/Source/platform/graphics/gpu/DrawingBuffer.cpp

 /*
  * Copyright (c) 2010, Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 72 matching lines @@
 private:
     gpu::gles2::GLES2Interface* m_gl;
     GLenum m_oldActiveTextureUnit;
     GLuint m_oldTextureUnitZeroId;
 };
 
 static bool shouldFailDrawingBufferCreationForTesting = false;
 
 } // namespace
 
-PassRefPtr<DrawingBuffer> DrawingBuffer::create(PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, const IntSize& size, bool premultipliedAlpha, PreserveDrawingBuffer preserve, WebGraphicsContext3D::Attributes requestedAttributes)
+PassRefPtr<DrawingBuffer> DrawingBuffer::create(PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, const IntSize& size, bool premultipliedAlpha, bool wantAlphaChannel, bool wantDepthBuffer, bool wantStencilBuffer, bool wantAntialiasing, PreserveDrawingBuffer preserve)
 {
     ASSERT(contextProvider);
 
     if (shouldFailDrawingBufferCreationForTesting) {
         shouldFailDrawingBufferCreationForTesting = false;
         return nullptr;
     }
 
     OwnPtr<Extensions3DUtil> extensionsUtil = Extensions3DUtil::create(contextProvider->contextGL());
     if (!extensionsUtil->isValid()) {
         // This might be the first time we notice that the GL context is lost.
         return nullptr;
     }
     ASSERT(extensionsUtil->supportsExtension("GL_OES_packed_depth_stencil"));
     extensionsUtil->ensureExtensionEnabled("GL_OES_packed_depth_stencil");
-    bool multisampleSupported = (extensionsUtil->supportsExtension("GL_CHROMIUM_framebuffer_multisample")
-        || extensionsUtil->supportsExtension("GL_EXT_multisampled_render_to_texture"))
+    bool multisampleSupported = wantAntialiasing
+        && (extensionsUtil->supportsExtension("GL_CHROMIUM_framebuffer_multisample")
+            || extensionsUtil->supportsExtension("GL_EXT_multisampled_render_to_texture"))
         && extensionsUtil->supportsExtension("GL_OES_rgb8_rgba8");
     if (multisampleSupported) {
         extensionsUtil->ensureExtensionEnabled("GL_OES_rgb8_rgba8");
         if (extensionsUtil->supportsExtension("GL_CHROMIUM_framebuffer_multisample"))
             extensionsUtil->ensureExtensionEnabled("GL_CHROMIUM_framebuffer_multisample");
         else
             extensionsUtil->ensureExtensionEnabled("GL_EXT_multisampled_render_to_texture");
     }
     bool discardFramebufferSupported = extensionsUtil->supportsExtension("GL_EXT_discard_framebuffer");
     if (discardFramebufferSupported)
         extensionsUtil->ensureExtensionEnabled("GL_EXT_discard_framebuffer");
 
-    RefPtr<DrawingBuffer> drawingBuffer = adoptRef(new DrawingBuffer(std::move(contextProvider), extensionsUtil.release(), multisampleSupported, discardFramebufferSupported, premultipliedAlpha, preserve, requestedAttributes));
-    if (!drawingBuffer->initialize(size)) {
+    RefPtr<DrawingBuffer> drawingBuffer = adoptRef(new DrawingBuffer(std::move(contextProvider), extensionsUtil.release(), discardFramebufferSupported, wantAlphaChannel, premultipliedAlpha, preserve));
+    if (!drawingBuffer->initialize(size, wantDepthBuffer, wantStencilBuffer, multisampleSupported)) {
         drawingBuffer->beginDestruction();
         return PassRefPtr<DrawingBuffer>();
     }
     return drawingBuffer.release();
 }
 
 void DrawingBuffer::forceNextDrawingBufferCreationToFail()
 {
     shouldFailDrawingBufferCreationForTesting = true;
 }
 
-DrawingBuffer::DrawingBuffer(PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, PassOwnPtr<Extensions3DUtil> extensionsUtil, bool multisampleExtensionSupported, bool discardFramebufferSupported, bool premultipliedAlpha, PreserveDrawingBuffer preserve, WebGraphicsContext3D::Attributes requestedAttributes)
+DrawingBuffer::DrawingBuffer(
+    PassOwnPtr<WebGraphicsContext3DProvider> contextProvider,
+    PassOwnPtr<Extensions3DUtil> extensionsUtil,
+    bool discardFramebufferSupported,
+    bool wantAlphaChannel,
+    bool premultipliedAlpha,
+    PreserveDrawingBuffer preserve)
     : m_preserveDrawingBuffer(preserve)
     , m_scissorEnabled(false)
     , m_texture2DBinding(0)
     , m_drawFramebufferBinding(0)
     , m_readFramebufferBinding(0)
     , m_activeTextureUnit(GL_TEXTURE0)
     , m_contextProvider(std::move(contextProvider))
     , m_context(m_contextProvider->context3d())
     , m_gl(m_contextProvider->contextGL())
     , m_extensionsUtil(std::move(extensionsUtil))
     , m_size(-1, -1)
-    , m_requestedAttributes(requestedAttributes)
-    , m_multisampleExtensionSupported(multisampleExtensionSupported)
     , m_discardFramebufferSupported(discardFramebufferSupported)
+    , m_wantAlphaChannel(wantAlphaChannel)
     , m_premultipliedAlpha(premultipliedAlpha)
+    , m_hasImplicitStencilBuffer(false)
     , m_fbo(0)
     , m_depthStencilBuffer(0)
     , m_multisampleFBO(0)
     , m_multisampleColorBuffer(0)
     , m_contentsChanged(true)
     , m_contentsChangeCommitted(false)
     , m_bufferClearNeeded(false)
     , m_antiAliasingMode(None)
     , m_maxTextureSize(0)
     , m_sampleCount(0)
@@ skipping 99 matching lines @@
         (*m_newMailboxCallback)();
 
     // Resolve the multisampled buffer into m_colorBuffer texture.
     if (m_antiAliasingMode != None)
         commit();
 
     if (bitmap) {
         bitmap->setSize(size());
 
         unsigned char* pixels = bitmap->pixels();
-        bool needPremultiply = m_actualAttributes.alpha && !m_premultipliedAlpha;
+        bool needPremultiply = m_wantAlphaChannel && !m_premultipliedAlpha;
         WebGLImageConversion::AlphaOp op = needPremultiply ? WebGLImageConversion::AlphaDoPremultiply : WebGLImageConversion::AlphaDoNothing;
         if (pixels)
             readBackFramebuffer(pixels, size().width(), size().height(), ReadbackSkia, op);
     }
 
     // We must restore the texture binding since creating new textures,
     // consuming and producing mailboxes changes it.
     ScopedTextureUnit0BindingRestorer restorer(m_gl, m_activeTextureUnit, m_texture2DBinding);
 
     // First try to recycle an old buffer.
     RefPtr<MailboxInfo> frontColorBufferMailbox = recycledMailbox();
 
     // No buffer available to recycle, create a new one.
-    if (!frontColorBufferMailbox) {
+    if (!frontColorBufferMailbox)
         frontColorBufferMailbox = createNewMailbox(createTextureAndAllocateMemory(m_size));
-    }
 
     if (m_preserveDrawingBuffer == Discard) {
         std::swap(frontColorBufferMailbox->textureInfo, m_colorBuffer);
         // It appears safe to overwrite the context's framebuffer binding in the Discard case since there will always be a
         // WebGLRenderingContext::clearIfComposited() call made before the next draw call which restores the framebuffer binding.
         // If this stops being true at some point, we should track the current framebuffer binding in the DrawingBuffer and restore
         // it after attaching the new back buffer here.
         m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
         attachColorBufferToCurrentFBO();
 
@@ skipping 62 matching lines @@
     return parameters;
 #else
     return defaultTextureParameters();
 #endif
 }
 
 DrawingBuffer::TextureParameters DrawingBuffer::defaultTextureParameters()
 {
     TextureParameters parameters;
     parameters.target = GL_TEXTURE_2D;
-    if (m_requestedAttributes.alpha) {
+    if (m_wantAlphaChannel) {
         parameters.internalColorFormat = GL_RGBA;
         parameters.colorFormat = GL_RGBA;
         parameters.internalRenderbufferFormat = GL_RGBA8_OES;
     } else {
         parameters.internalColorFormat = GL_RGB;
         parameters.colorFormat = GL_RGB;
         parameters.internalRenderbufferFormat = GL_RGB8_OES;
     }
     return parameters;
 }
@@ skipping 61 matching lines @@
             deleteChromiumImageForTexture(&m_textureMailboxes[i]->textureInfo);
 
             m_gl->DeleteTextures(1, &m_textureMailboxes[i]->textureInfo.textureId);
             m_textureMailboxes.remove(i);
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
 
-bool DrawingBuffer::initialize(const IntSize& size)
+bool DrawingBuffer::initialize(const IntSize& size, bool wantDepthBuffer, bool wantStencilBuffer, bool useMultisampling)
 {
     if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
         // Need to try to restore the context again later.
         return false;
     }
 
     m_gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &m_maxTextureSize);
 
     int maxSampleCount = 0;
     m_antiAliasingMode = None;
-    if (m_requestedAttributes.antialias && m_multisampleExtensionSupported) {
+    if (useMultisampling) {
         m_gl->GetIntegerv(GL_MAX_SAMPLES_ANGLE, &maxSampleCount);
         m_antiAliasingMode = MSAAExplicitResolve;
         if (m_extensionsUtil->supportsExtension("GL_EXT_multisampled_render_to_texture")) {
             m_antiAliasingMode = MSAAImplicitResolve;
         } else if (m_extensionsUtil->supportsExtension("GL_CHROMIUM_screen_space_antialiasing")) {
             m_antiAliasingMode = ScreenSpaceAntialiasing;
         }
     }
     m_sampleCount = std::min(4, maxSampleCount);
 
     m_gl->GenFramebuffers(1, &m_fbo);
 
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     createSecondaryBuffers();
-    // We first try to initialize everything with the requested attributes.
-    if (!reset(size))
+    if (!reset(size, wantDepthBuffer || wantStencilBuffer))
         return false;
-    // If that succeeds, we then see what we actually got and update our actual attributes to reflect that.
-    m_actualAttributes = m_requestedAttributes;
-    if (m_requestedAttributes.alpha) {
-        GLint alphaBits = 0;
-        m_gl->GetIntegerv(GL_ALPHA_BITS, &alphaBits);
-        m_actualAttributes.alpha = alphaBits > 0;
+
+    if (m_depthStencilBuffer) {
+        DCHECK(wantDepthBuffer || wantStencilBuffer);
+        m_hasImplicitStencilBuffer = !wantStencilBuffer;
     }
-    if (m_requestedAttributes.depth) {
-        GLint depthBits = 0;
-        m_gl->GetIntegerv(GL_DEPTH_BITS, &depthBits);
-        m_actualAttributes.depth = depthBits > 0;
-    }
-    if (m_requestedAttributes.stencil) {
-        GLint stencilBits = 0;
-        m_gl->GetIntegerv(GL_STENCIL_BITS, &stencilBits);
-        m_actualAttributes.stencil = stencilBits > 0;
-    }
-    m_actualAttributes.antialias = multisample();
 
     if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
         // It's possible that the drawing buffer allocation provokes a context loss, so check again just in case. http://crbug.com/512302
         return false;
     }
 
     return true;
 }
 
 bool DrawingBuffer::copyToPlatformTexture(WebGraphicsContext3D* context, gpu::gles2::GLES2Interface* gl, GLuint texture, GLenum internalFormat,
@@ skipping 29 matching lines @@
         m_gl->GenSyncTokenCHROMIUM(fenceSync, mailbox.syncToken);
         mailbox.validSyncToken = true;
     }
 
     if (mailbox.validSyncToken)
         gl->WaitSyncTokenCHROMIUM(mailbox.syncToken);
     GLuint sourceTexture = gl->CreateAndConsumeTextureCHROMIUM(target, mailbox.name);
 
     GLboolean unpackPremultiplyAlphaNeeded = GL_FALSE;
     GLboolean unpackUnpremultiplyAlphaNeeded = GL_FALSE;
-    if (m_actualAttributes.alpha && m_premultipliedAlpha && !premultiplyAlpha)
+    if (m_wantAlphaChannel && m_premultipliedAlpha && !premultiplyAlpha)
         unpackUnpremultiplyAlphaNeeded = GL_TRUE;
-    else if (m_actualAttributes.alpha && !m_premultipliedAlpha && premultiplyAlpha)
+    else if (m_wantAlphaChannel && !m_premultipliedAlpha && premultiplyAlpha)
         unpackPremultiplyAlphaNeeded = GL_TRUE;
 
     gl->CopyTextureCHROMIUM(sourceTexture, texture, internalFormat, destType, flipY, unpackPremultiplyAlphaNeeded, unpackUnpremultiplyAlphaNeeded);
 
     gl->DeleteTextures(1, &sourceTexture);
 
     const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM();
 
     gl->Flush();
     GLbyte syncToken[24];
     gl->GenSyncTokenCHROMIUM(fenceSync, syncToken);
     m_gl->WaitSyncTokenCHROMIUM(syncToken);
 
     return true;
 }
 
 GLuint DrawingBuffer::framebuffer() const
 {
     return m_fbo;
 }
 
 WebLayer* DrawingBuffer::platformLayer()
 {
     if (!m_layer) {
         m_layer = adoptPtr(Platform::current()->compositorSupport()->createExternalTextureLayer(this));
 
-        m_layer->setOpaque(!m_actualAttributes.alpha);
-        m_layer->setBlendBackgroundColor(m_actualAttributes.alpha);
+        m_layer->setOpaque(!m_wantAlphaChannel);
+        m_layer->setBlendBackgroundColor(m_wantAlphaChannel);
         m_layer->setPremultipliedAlpha(m_premultipliedAlpha);
         m_layer->setNearestNeighbor(m_filterQuality == kNone_SkFilterQuality);
         GraphicsLayer::registerContentsLayer(m_layer->layer());
     }
 
     return m_layer->layer();
 }
 
 void DrawingBuffer::clearPlatformLayer()
 {
@@ skipping 58 matching lines @@
 void DrawingBuffer::createSecondaryBuffers()
 {
     // create a multisample FBO
     if (m_antiAliasingMode == MSAAExplicitResolve) {
         m_gl->GenFramebuffers(1, &m_multisampleFBO);
         m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
         m_gl->GenRenderbuffers(1, &m_multisampleColorBuffer);
     }
 }
 
-bool DrawingBuffer::resizeFramebuffer(const IntSize& size)
+bool DrawingBuffer::resizeFramebuffer(const IntSize& size, bool wantDepthOrStencilBuffer)
 {
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
-    if (m_antiAliasingMode != MSAAExplicitResolve)
+    if (m_antiAliasingMode != MSAAExplicitResolve && wantDepthOrStencilBuffer)
         resizeDepthStencil(size);
     if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
         return false;
 
     return true;
 }
 
-bool DrawingBuffer::resizeMultisampleFramebuffer(const IntSize& size)
+bool DrawingBuffer::resizeMultisampleFramebuffer(const IntSize& size, bool wantDepthOrStencilBuffer)
 {
     if (m_antiAliasingMode == MSAAExplicitResolve) {
         m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
 
         m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_multisampleColorBuffer);
         m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, m_colorBuffer.parameters.internalRenderbufferFormat, size.width(), size.height());
 
         if (m_gl->GetError() == GL_OUT_OF_MEMORY)
             return false;
 
         m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_multisampleColorBuffer);
-        resizeDepthStencil(size);
+        if (wantDepthOrStencilBuffer)
+            resizeDepthStencil(size);
         if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
             return false;
     }
 
     return true;
 }
 
 void DrawingBuffer::resizeDepthStencil(const IntSize& size)
 {
-    if (!m_requestedAttributes.depth && !m_requestedAttributes.stencil)
-        return;
-
     if (!m_depthStencilBuffer)
         m_gl->GenRenderbuffers(1, &m_depthStencilBuffer);
     m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
     if (m_antiAliasingMode == MSAAImplicitResolve)
         m_gl->RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     else if (m_antiAliasingMode == MSAAExplicitResolve)
         m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     else
         m_gl->RenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
     m_gl->BindRenderbuffer(GL_RENDERBUFFER, 0);
 }
 
 
 
 void DrawingBuffer::clearFramebuffers(GLbitfield clearMask)
 {
     // We will clear the multisample FBO, but we also need to clear the non-multisampled buffer.
     if (m_multisampleFBO) {
         m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
         m_gl->Clear(GL_COLOR_BUFFER_BIT);
     }
 
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo);
     m_gl->Clear(clearMask);
 }
 
-bool DrawingBuffer::hasImplicitStencilBuffer() const
-{
-    return m_depthStencilBuffer && m_requestedAttributes.depth && !m_requestedAttributes.stencil;
-}
-
 void DrawingBuffer::setSize(const IntSize& size)
 {
     if (m_size == size)
         return;
 
     m_size = size;
 }
 
 IntSize DrawingBuffer::adjustSize(const IntSize& desiredSize, const IntSize& curSize, int maxTextureSize)
 {
     IntSize adjustedSize = desiredSize;
 
     // Clamp if the desired size is greater than the maximum texture size for the device.
     if (adjustedSize.height() > maxTextureSize)
         adjustedSize.setHeight(maxTextureSize);
 
     if (adjustedSize.width() > maxTextureSize)
         adjustedSize.setWidth(maxTextureSize);
 
     return adjustedSize;
 }
 
-bool DrawingBuffer::reset(const IntSize& newSize)
+bool DrawingBuffer::reset(const IntSize& newSize, bool wantDepthOrStencilBuffer)
 {
     ASSERT(!newSize.isEmpty());
     IntSize adjustedSize = adjustSize(newSize, m_size, m_maxTextureSize);
     if (adjustedSize.isEmpty())
         return false;
 
     if (adjustedSize != m_size) {
         do {
             if (m_colorBuffer.textureId) {
                 resizeTextureMemory(&m_colorBuffer, adjustedSize);
             } else {
                 m_colorBuffer = createTextureAndAllocateMemory(adjustedSize);
             }
 
             m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
             attachColorBufferToCurrentFBO();
 
             // resize multisample FBO
-            if (!resizeMultisampleFramebuffer(adjustedSize) || !resizeFramebuffer(adjustedSize)) {
+            if (!resizeMultisampleFramebuffer(adjustedSize, wantDepthOrStencilBuffer)
+                || !resizeFramebuffer(adjustedSize, wantDepthOrStencilBuffer)) {
                 adjustedSize.scale(s_resourceAdjustedRatio);
                 continue;
             }
             break;
         } while (!adjustedSize.isEmpty());
 
         setSize(adjustedSize);
 
         if (adjustedSize.isEmpty())
             return false;
     }
 
     m_gl->Disable(GL_SCISSOR_TEST);
     m_gl->ClearColor(0, 0, 0, 0);
     m_gl->ColorMask(true, true, true, true);
 
     GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
-    if (m_actualAttributes.depth) {
+    if (!!m_depthStencilBuffer) {
         m_gl->ClearDepthf(1.0f);
         clearMask |= GL_DEPTH_BUFFER_BIT;
         m_gl->DepthMask(true);
     }
-    if (m_actualAttributes.stencil) {
+    if (!!m_depthStencilBuffer) {
         m_gl->ClearStencil(0);
         clearMask |= GL_STENCIL_BUFFER_BIT;
         m_gl->StencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
     }
 
     clearFramebuffers(clearMask);
     return true;
 }
 
 void DrawingBuffer::commit()
@@ skipping 160 matching lines @@
         m_gl->DestroyImageCHROMIUM(info->imageId);
         info->imageId = 0;
     }
 }
 
 DrawingBuffer::TextureInfo DrawingBuffer::createTextureAndAllocateMemory(const IntSize& size)
 {
     // TODO(erikchen): Add support for a CHROMIUM_image back buffer whose
     // behavior mimics a texture with internal format GL_RGB.
     // https://crbug.com/581777.
-    if (!m_requestedAttributes.alpha)
+    if (!m_wantAlphaChannel)
         return createDefaultTextureAndAllocateMemory(size);
 
     if (!RuntimeEnabledFeatures::webGLImageChromiumEnabled())
         return createDefaultTextureAndAllocateMemory(size);
 
     // First, try to allocate a CHROMIUM_image. This always has the potential to
     // fail.
     TextureParameters parameters = chromiumImageTextureParameters();
     GLuint imageId = m_gl->CreateGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), parameters.internalColorFormat, GC3D_SCANOUT_CHROMIUM);
     if (!imageId)
@@ skipping 51 matching lines @@
 
     if (m_antiAliasingMode == MSAAImplicitResolve)
         m_gl->FramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, m_colorBuffer.textureId, 0, m_sampleCount);
     else
         m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, m_colorBuffer.textureId, 0);
 
     m_gl->BindTexture(GL_TEXTURE_2D, m_texture2DBinding);
 }
 
 } // namespace blink