Prevent implicit framebuffer clear from clobbering alpha in emulated RGB

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 122 matching lines @@
       ThreadSpecific<WebGLRenderingContextBaseMap>, forciblyEvictedContexts,
       new ThreadSpecific<WebGLRenderingContextBaseMap>());
   if (!forciblyEvictedContexts.isSet())
     forciblyEvictedContexts->registerAsStaticReference();
   return *forciblyEvictedContexts;
 }
 
 }  // namespace
 
 ScopedRGBEmulationColorMask::ScopedRGBEmulationColorMask(
-    gpu::gles2::GLES2Interface* contextGL,
+    WebGLRenderingContextBase* context,
     GLboolean* colorMask,
     DrawingBuffer* drawingBuffer)
-    : m_contextGL(contextGL),
+    : m_context(context),
       m_requiresEmulation(drawingBuffer->requiresAlphaChannelToBePreserved()) {
   if (m_requiresEmulation) {
+    m_context->m_activeScopedRGBEmulationColorMasks++;
     memcpy(m_colorMask, colorMask, 4 * sizeof(GLboolean));
-    m_contextGL->ColorMask(m_colorMask[0], m_colorMask[1], m_colorMask[2],
-                           false);
+    m_context->contextGL()->ColorMask(m_colorMask[0], m_colorMask[1],
+                                      m_colorMask[2], false);
   }
 }
 
 ScopedRGBEmulationColorMask::~ScopedRGBEmulationColorMask() {
-  if (m_requiresEmulation)
-    m_contextGL->ColorMask(m_colorMask[0], m_colorMask[1], m_colorMask[2],
-                           m_colorMask[3]);
+  if (m_requiresEmulation) {
+    DCHECK(m_context->m_activeScopedRGBEmulationColorMasks);
+    m_context->m_activeScopedRGBEmulationColorMasks--;
+    m_context->contextGL()->ColorMask(m_colorMask[0], m_colorMask[1],
+                                      m_colorMask[2], m_colorMask[3]);
+  }
 }
 
 void WebGLRenderingContextBase::forciblyLoseOldestContext(
     const String& reason) {
   WebGLRenderingContextBase* candidate = oldestContext();
   if (!candidate)
     return;
 
   candidate->printWarningToConsole(reason);
   InspectorInstrumentation::didFireWebGLWarning(candidate->canvas());
@@ skipping 1788 matching lines @@
     return;
   }
   const char* reason = "framebuffer incomplete";
   if (m_framebufferBinding &&
       m_framebufferBinding->checkDepthStencilStatus(&reason) !=
           GL_FRAMEBUFFER_COMPLETE) {
     synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, "clear", reason);
     return;
   }
 
-  ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask,
+  ScopedRGBEmulationColorMask emulationColorMask(this, m_colorMask,
                                                  m_drawingBuffer.get());
 
   if (clearIfComposited(mask) != CombinedClear) {
     // If clearing the default back buffer's depth buffer, also clear the
     // stencil buffer, if one was allocated implicitly. This avoids performance
     // problems on some GPUs.
     if (!m_framebufferBinding && drawingBuffer()->hasImplicitStencilBuffer() &&
         (mask & GL_DEPTH_BUFFER_BIT)) {
       // It shouldn't matter what value it's cleared to, since in other queries
       // in the API, we claim that the stencil buffer doesn't exist.
@@ skipping 438 matching lines @@
                                            GLsizei count) {
   if (!validateDrawArrays("drawArrays"))
     return;
 
   if (!m_boundVertexArrayObject->isAllEnabledAttribBufferBound()) {
     synthesizeGLError(GL_INVALID_OPERATION, "drawArrays",
                       "no buffer is bound to enabled attribute");
     return;
   }
 
-  ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask,
+  ScopedRGBEmulationColorMask emulationColorMask(this, m_colorMask,
                                                  m_drawingBuffer.get());
   clearIfComposited();
   contextGL()->DrawArrays(mode, first, count);
   markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::drawElements(GLenum mode,
                                              GLsizei count,
                                              GLenum type,
                                              long long offset) {
   if (!validateDrawElements("drawElements", type, offset))
     return;
 
   if (!m_boundVertexArrayObject->isAllEnabledAttribBufferBound()) {
     synthesizeGLError(GL_INVALID_OPERATION, "drawElements",
                       "no buffer is bound to enabled attribute");
     return;
   }
 
-  ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask,
+  ScopedRGBEmulationColorMask emulationColorMask(this, m_colorMask,
                                                  m_drawingBuffer.get());
   clearIfComposited();
   contextGL()->DrawElements(
       mode, count, type,
       reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
   markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::drawArraysInstancedANGLE(GLenum mode,
                                                          GLint first,
                                                          GLsizei count,
                                                          GLsizei primcount) {
   if (!validateDrawArrays("drawArraysInstancedANGLE"))
     return;
 
   if (!m_boundVertexArrayObject->isAllEnabledAttribBufferBound()) {
     synthesizeGLError(GL_INVALID_OPERATION, "drawArraysInstancedANGLE",
                       "no buffer is bound to enabled attribute");
     return;
   }
 
-  ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask,
+  ScopedRGBEmulationColorMask emulationColorMask(this, m_colorMask,
                                                  m_drawingBuffer.get());
   clearIfComposited();
   contextGL()->DrawArraysInstancedANGLE(mode, first, count, primcount);
   markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::drawElementsInstancedANGLE(GLenum mode,
                                                            GLsizei count,
                                                            GLenum type,
                                                            long long offset,
                                                            GLsizei primcount) {
   if (!validateDrawElements("drawElementsInstancedANGLE", type, offset))
     return;
 
   if (!m_boundVertexArrayObject->isAllEnabledAttribBufferBound()) {
     synthesizeGLError(GL_INVALID_OPERATION, "drawElementsInstancedANGLE",
                       "no buffer is bound to enabled attribute");
     return;
   }
 
-  ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask,
+  ScopedRGBEmulationColorMask emulationColorMask(this, m_colorMask,
                                                  m_drawingBuffer.get());
   clearIfComposited();
   contextGL()->DrawElementsInstancedANGLE(
       mode, count, type, reinterpret_cast<void*>(static_cast<intptr_t>(offset)),
       primcount);
   markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::enable(GLenum cap) {
   if (isContextLost() || !validateCapability("enable", cap))
@@ skipping 3780 matching lines @@
     return;
   if (m_scissorEnabled)
     contextGL()->Enable(GL_SCISSOR_TEST);
   else
     contextGL()->Disable(GL_SCISSOR_TEST);
 }
 
 void WebGLRenderingContextBase::DrawingBufferClientRestoreMaskAndClearValues() {
   if (!contextGL())
     return;
+  bool colorMaskAlpha =
+      m_colorMask[3] && m_activeScopedRGBEmulationColorMasks == 0;
   contextGL()->ColorMask(m_colorMask[0], m_colorMask[1], m_colorMask[2],
-                         m_colorMask[3]);
+                         colorMaskAlpha);
   contextGL()->DepthMask(m_depthMask);
   contextGL()->StencilMaskSeparate(GL_FRONT, m_stencilMask);
 
   contextGL()->ClearColor(m_clearColor[0], m_clearColor[1], m_clearColor[2],
                           m_clearColor[3]);
   contextGL()->ClearDepthf(m_clearDepth);
   contextGL()->ClearStencil(m_clearStencil);
 }
 
 void WebGLRenderingContextBase::DrawingBufferClientRestorePixelPackAlignment() {
@@ skipping 1460 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink