Enable WebGL rendering into ImageCHROMIUM, backed by a scanout buffer to enable overlay suppor…

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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "platform/graphics/gpu/DrawingBuffer.h"
 
+#include "RuntimeEnabledFeatures.h"
 #include <algorithm>
 #include "platform/TraceEvent.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebExternalBitmap.h"
 #include "public/platform/WebExternalTextureLayer.h"
 #include "public/platform/WebGraphicsContext3D.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
@@ skipping 176 matching lines @@
 
     // We must restore the texture binding since creating new textures,
     // consuming and producing mailboxes changes it.
     ScopedTextureUnit0BindingRestorer restorer(m_context.get(), 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) {
-        unsigned newColorBuffer = createColorTexture(m_size);
+        unsigned newColorBuffer = createColorTexture();
+        allocateTextureMemory(newColorBuffer, m_size);
         // Bad things happened, abandon ship.
         if (!newColorBuffer)
             return false;
 
         frontColorBufferMailbox = createNewMailbox(newColorBuffer);
     }
 
     if (m_preserveDrawingBuffer == Discard) {
         swap(frontColorBufferMailbox->textureId, m_colorBuffer);
         // It appears safe to overwrite the context's framebuffer binding in the Discard case since there will always be a
@@ skipping 13 matching lines @@
         bind();
     else
         restoreFramebufferBinding();
 
     m_contentsChanged = false;
 
     m_context->bindTexture(GL_TEXTURE_2D, frontColorBufferMailbox->textureId);
     m_context->produceTextureCHROMIUM(GL_TEXTURE_2D, frontColorBufferMailbox->mailbox.name);
     m_context->flush();
     frontColorBufferMailbox->mailbox.syncPoint = m_context->insertSyncPoint();
+    frontColorBufferMailbox->mailbox.allowOverlay = m_textureToImageChromiumMap.find(frontColorBufferMailbox->textureId) != m_textureToImageChromiumMap.end();
     markLayerComposited();
 
     // set m_parentDrawingBuffer to make sure 'this' stays alive as long as it has live mailboxes
     ASSERT(!frontColorBufferMailbox->m_parentDrawingBuffer);
     frontColorBufferMailbox->m_parentDrawingBuffer = this;
     *outMailbox = frontColorBufferMailbox->mailbox;
     m_frontColorBuffer = frontColorBufferMailbox->textureId;
     return true;
 }
 
@@ skipping 41 matching lines @@
     }
     ASSERT(mailboxInfo);
 
     if (mailboxInfo->mailbox.syncPoint) {
         m_context->waitSyncPoint(mailboxInfo->mailbox.syncPoint);
         mailboxInfo->mailbox.syncPoint = 0;
     }
 
     if (mailboxInfo->size != m_size) {
         m_context->bindTexture(GL_TEXTURE_2D, mailboxInfo->textureId);
-        texImage2DResourceSafe(GL_TEXTURE_2D, 0, m_internalColorFormat, m_size.width(), m_size.height(), 0, m_colorFormat, GL_UNSIGNED_BYTE);
+        allocateTextureMemory(mailboxInfo->textureId, m_size);
         mailboxInfo->size = m_size;
     }
 
     return mailboxInfo.release();
 }
 
 PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::createNewMailbox(unsigned textureId)
 {
     RefPtr<MailboxInfo> returnMailbox = adoptRef(new MailboxInfo());
     m_context->genMailboxCHROMIUM(returnMailbox->mailbox.name);
     returnMailbox->textureId = textureId;
     returnMailbox->size = m_size;
     m_textureMailboxes.append(returnMailbox);
     return returnMailbox.release();
 }
 
 void DrawingBuffer::deleteMailbox(const blink::WebExternalTextureMailbox& mailbox)
 {
     for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
         if (nameEquals(m_textureMailboxes[i]->mailbox, mailbox)) {
             if (mailbox.syncPoint)
                 m_context->waitSyncPoint(mailbox.syncPoint);
+            if (RuntimeEnabledFeatures::webGLImageChromiumEnabled())
+                deleteChromiumImageForTexture(m_textureMailboxes[i]->textureId);
+
             m_context->deleteTexture(m_textureMailboxes[i]->textureId);
             m_textureMailboxes.remove(i);
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
 
 bool DrawingBuffer::initialize(const IntSize& size)
 {
@@ skipping 164 matching lines @@
         context->deleteTexture(sourceTexture);
         context->flush();
         m_context->waitSyncPoint(context->insertSyncPoint());
         return;
     }
 
     // Since the m_frontColorBuffer was produced and sent to the compositor, it cannot be bound to an fbo.
     // We have to make a copy of it here and bind that copy instead.
     // FIXME: That's not true any more, provided we don't change texture
     // parameters.
-    unsigned sourceTexture = createColorTexture(m_size);
+    unsigned sourceTexture = createColorTexture();
+    texImage2DResourceSafe(GL_TEXTURE_2D, 0, m_internalColorFormat, m_size.width(), m_size.height(), 0, m_colorFormat, GL_UNSIGNED_BYTE);
     m_context->copyTextureCHROMIUM(GL_TEXTURE_2D, m_frontColorBuffer, sourceTexture, 0, GL_RGBA, GL_UNSIGNED_BYTE);
 
     // Since we're using the same context as WebGL, we have to restore any state we change (in this case, just the framebuffer binding).
     // FIXME: The WebGLRenderingContext tracks the current framebuffer binding, it would be slightly more efficient to use this value
     // rather than querying it off of the context.
     GLint previousFramebuffer = 0;
     m_context->getIntegerv(GL_FRAMEBUFFER_BINDING, &previousFramebuffer);
 
     Platform3DObject framebuffer = m_context->createFramebuffer();
     m_context->bindFramebuffer(GL_FRAMEBUFFER, framebuffer);
@@ skipping 37 matching lines @@
 
     if (m_depthStencilBuffer)
         m_context->deleteRenderbuffer(m_depthStencilBuffer);
 
     if (m_depthBuffer)
         m_context->deleteRenderbuffer(m_depthBuffer);
 
     if (m_stencilBuffer)
         m_context->deleteRenderbuffer(m_stencilBuffer);
 
-    if (m_colorBuffer)
+    if (m_colorBuffer) {
+        if (RuntimeEnabledFeatures::webGLImageChromiumEnabled())
+            deleteChromiumImageForTexture(m_colorBuffer);
+
         m_context->deleteTexture(m_colorBuffer);
+    }
 
     setSize(IntSize());
 
     m_colorBuffer = 0;
     m_frontColorBuffer = 0;
     m_multisampleColorBuffer = 0;
     m_depthStencilBuffer = 0;
     m_depthBuffer = 0;
     m_stencilBuffer = 0;
     m_multisampleFBO = 0;
     m_fbo = 0;
     m_contextEvictionManager.clear();
 
     if (m_layer)
         GraphicsLayer::unregisterContentsLayer(m_layer->layer());
 }
 
-unsigned DrawingBuffer::createColorTexture(const IntSize& size)
+unsigned DrawingBuffer::createColorTexture()
 {
     unsigned offscreenColorTexture = m_context->createTexture();
     if (!offscreenColorTexture)
         return 0;
 
     m_context->bindTexture(GL_TEXTURE_2D, offscreenColorTexture);
     m_context->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     m_context->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     m_context->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     m_context->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    if (!size.isEmpty())
-        texImage2DResourceSafe(GL_TEXTURE_2D, 0, m_internalColorFormat, size.width(), size.height(), 0, m_colorFormat, GL_UNSIGNED_BYTE);
 
     return offscreenColorTexture;
 }
 
 void DrawingBuffer::createSecondaryBuffers()
 {
     // create a multisample FBO
     if (m_multisampleMode == ExplicitResolve) {
         m_multisampleFBO = m_context->createFramebuffer();
         m_context->bindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
         m_multisampleColorBuffer = m_context->createRenderbuffer();
     }
 }
 
 bool DrawingBuffer::resizeFramebuffer(const IntSize& size)
 {
     // resize regular FBO
     m_context->bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
 
     m_context->bindTexture(GL_TEXTURE_2D, m_colorBuffer);
 
-    texImage2DResourceSafe(GL_TEXTURE_2D, 0, m_internalColorFormat, size.width(), size.height(), 0, m_colorFormat, GL_UNSIGNED_BYTE);
+    allocateTextureMemory(m_colorBuffer, size);
 
     if (m_multisampleMode == ImplicitResolve)
         m_context->framebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorBuffer, 0, m_sampleCount);
     else
         m_context->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorBuffer, 0);
 
     m_context->bindTexture(GL_TEXTURE_2D, 0);
 
     if (m_multisampleMode != ExplicitResolve)
         resizeDepthStencil(size);
@@ skipping 358 matching lines @@
         memcpy(rowA, scanline, rowBytes);
     }
 }
 
 void DrawingBuffer::texImage2DResourceSafe(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLint unpackAlignment)
 {
     ASSERT(unpackAlignment == 1 || unpackAlignment == 2 || unpackAlignment == 4 || unpackAlignment == 8);
     m_context->texImage2D(target, level, internalformat, width, height, border, format, type, 0);
 }
 
+void DrawingBuffer::allocateTextureMemory(Platform3DObject textureId, const IntSize& size)
+{
+    if (RuntimeEnabledFeatures::webGLImageChromiumEnabled()) {
+        deleteChromiumImageForTexture(textureId);
+
+        blink::WGC3Duint newImage = m_context->createImageCHROMIUM(size.width(), size.height(), GL_RGBA8_OES, GC3D_IMAGE_SCANOUT_CHROMIUM);
+        if (newImage) {

[Ken Russell (switch to Gerrit), 2014/05/14 22:11:33]

Under what conditions will createImageCHROMIUM fail? Does the compositor still
render things properly if that happens?

[alexst (slow to review), 2014/05/14 22:29:55]

There may be a limit of memory available to scanout buffers on some hardware,
for example.

But it should fail over gracefully since overlay decisions are made on a per
buffer basis and if no buffer is available above, we'll just make a regular
texture and go on about our business by compositing in GL intead.

+            m_context->bindTexImage2DCHROMIUM(GL_TEXTURE_2D, newImage);
+            m_textureToImageChromiumMap.add(textureId, newImage);

[Ken Russell (switch to Gerrit), 2014/05/14 22:11:33]

The bookkeeping associated with these ImageChromium objects adds more complexity
to already-complex code. Could you think of a way to encapsulate things more?
Maybe add an inner class to DrawingBuffer which would wrap up the texture ID and
any associated ImageChromium object?

[alexst (slow to review), 2014/05/14 22:29:55]

Let me have a look.

+            return;
+        }
+    }
+
+    texImage2DResourceSafe(GL_TEXTURE_2D, 0, m_internalColorFormat, size.width(), size.height(), 0, m_colorFormat, GL_UNSIGNED_BYTE);
+}
+
+void DrawingBuffer::deleteChromiumImageForTexture(Platform3DObject textureId)
+{
+    HashMap<Platform3DObject, blink::WGC3Duint>::iterator imageIter = m_textureToImageChromiumMap.find(textureId);
+    // Release the old buffer if we have any.
+    if (imageIter != m_textureToImageChromiumMap.end()) {
+        m_context->releaseTexImage2DCHROMIUM(GL_TEXTURE_2D, imageIter->value);
+        m_context->destroyImageCHROMIUM(imageIter->value);
+        m_textureToImageChromiumMap.remove(imageIter);
+    }
+}
+
 } // namespace WebCore