mac: Use IOSurfaces in Canvas2DLayerBridge.

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.cpp

 /*
  * Copyright (C) 2012 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:
  *
  * 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
@@ skipping 183 matching lines @@
     // of the canvas would result in the canvas being accelerated. Presentation is assumed to be
     // a 'PreferAcceleration' operation.
     return shouldAccelerate(PreferAcceleration);
 }
 
 GLenum Canvas2DLayerBridge::getGLFilter()
 {
     return m_filterQuality == kNone_SkFilterQuality ? GL_NEAREST : GL_LINEAR;
 }
 
+bool Canvas2DLayerBridge::prepareIOSurfaceMailboxFromImage(RefPtr<SkImage>& image, WebExternalTextureMailbox* outMailbox)
+{
+    GLuint textureId, imageId;
+    if (!createIOSurfaceBackedTexture(&textureId, &imageId))
+        return false;
+
+    GLuint imageTexture = skia::GrBackendObjectToGrGLTextureInfo(image->getTextureHandle(true))->fID;
+    context()->copyTextureCHROMIUM(imageTexture, textureId, GL_BGRA_EXT, GL_UNSIGNED_BYTE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+    MailboxInfo& info = createMailboxInfo();
+    info.m_mailbox.textureTarget = GC3D_TEXTURE_RECTANGLE_ARB;
+    context()->genMailboxCHROMIUM(info.m_mailbox.name);
+    context()->produceTextureDirectCHROMIUM(textureId, info.m_mailbox.textureTarget, info.m_mailbox.name);
+    info.m_mailbox.allowOverlay = true;
+    info.m_mailbox.nearestNeighbor = getGLFilter();
+
+    const WGC3Duint64 fenceSync = context()->insertFenceSyncCHROMIUM();
+    context()->flush();
+    info.m_mailbox.validSyncToken = context()->genSyncTokenCHROMIUM(fenceSync, info.m_mailbox.syncToken);
+
+    info.m_CHROMIUMImageId = imageId;
+    info.m_textureId = textureId;
+    *outMailbox = info.m_mailbox;
+
+    // Because we are changing the texture binding without going through skia,
+    // we must dirty the context.
+    GrContext* grContext = m_contextProvider->grContext();
+    grContext->resetContext(kTextureBinding_GrGLBackendState);
+
+    return true;
+}
+
+bool Canvas2DLayerBridge::createIOSurfaceBackedTexture(GLuint* outTexture, GLuint* outImageId)
+{
+    WebGraphicsContext3D* webContext = context();
+    GLuint imageId = webContext->createGpuMemoryBufferImageCHROMIUM(m_size.width(), m_size.height(), GL_BGRA_EXT, GC3D_SCANOUT_CHROMIUM);
+    if (!imageId)
+        return false;
+
+    GLuint textureId= webContext->createTexture();
+    if (!textureId) {
+        webContext->destroyImageCHROMIUM(imageId);
+        return false;
+    }
+
+    GLenum target = GC3D_TEXTURE_RECTANGLE_ARB;
+    webContext->bindTexture(target, textureId);
+    webContext->texParameteri(target, GL_TEXTURE_MAG_FILTER, getGLFilter());
+    webContext->texParameteri(target, GL_TEXTURE_MIN_FILTER, getGLFilter());
+    webContext->texParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    webContext->texParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    webContext->bindTexImage2DCHROMIUM(target, imageId);
+
+    *outTexture = textureId;
+    *outImageId = imageId;
+    return true;
+}
+
 Canvas2DLayerBridge::MailboxInfo& Canvas2DLayerBridge::createMailboxInfo()
 {
     MailboxInfo tmp;
     tmp.m_parentLayerBridge = this;
     m_mailboxes.prepend(tmp);
     MailboxInfo& mailboxInfo = m_mailboxes.first();
     return mailboxInfo;
 }
 
 bool Canvas2DLayerBridge::prepareMailboxFromImage(RefPtr<SkImage>& image, WebExternalTextureMailbox* outMailbox)
 {
+    GrContext* grContext = m_contextProvider->grContext();
+    if (RuntimeEnabledFeatures::canvas2dImageChromiumEnabled()) {
+        if (grContext && prepareIOSurfaceMailboxFromImage(image, outMailbox))

[Justin Novosad, 2016/03/02 16:33:45]

I think what you want here is:
if (!grContext)
    return true; // For unit tests
if (prepareIOSurfaceMailboxFromImage(image, outMailbox))
    return false;
// Note: if IOSurface backed texture creation failed we fall back to the
non-IOSurface path.

+            return true;
+    }
+
     MailboxInfo& mailboxInfo = createMailboxInfo();
     mailboxInfo.m_mailbox.nearestNeighbor = getGLFilter() == GL_NEAREST;
     mailboxInfo.m_image = image;
 
-    GrContext* grContext = m_contextProvider->grContext();
     if (!grContext)
         return true; // for testing: skip gl stuff when using a mock graphics context.
 
     if (RuntimeEnabledFeatures::forceDisable2dCanvasCopyOnWriteEnabled())
         m_surface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
 
     // Need to flush skia's internal queue because texture is about to be accessed directly
     grContext->flush();
 
     // Because of texture sharing with the compositor, we must invalidate
@@ skipping 485 matching lines @@
     while (true) {
         --releasedMailboxInfo;
         if (nameEquals(releasedMailboxInfo->m_mailbox, mailbox)) {
             break;
         }
         ASSERT(releasedMailboxInfo != firstMailbox);
     }
 
     if (!contextLost) {
         // Invalidate texture state in case the compositor altered it since the copy-on-write.
         if (releasedMailboxInfo->m_image) {

[Justin Novosad, 2016/03/02 16:33:45]

ASSERT(!releasedMailboxInfo->m_CHROMIUMImageId)

             if (mailbox.validSyncToken) {
                 context()->waitSyncTokenCHROMIUM(mailbox.syncToken);
             }
             GrTexture* texture = releasedMailboxInfo->m_image->getTexture();
             if (texture) {
                 if (lostResource) {
                     texture->abandon();
                 } else {
                     texture->textureParamsModified();
                 }
             }
         }
+
+        if (releasedMailboxInfo->m_CHROMIUMImageId) {
+            ASSERT(releasedMailboxInfo->m_textureId);
+            ASSERT(!releasedMailboxInfo->m_image);
+            if (mailbox.validSyncToken) {
+                context()->waitSyncTokenCHROMIUM(mailbox.syncToken);

[Justin Novosad, 2016/03/02 16:33:45]

This synchronisation is probably unnecessary? In the case of the other code
path, the only reason we needed to sync is because the textures got recycled by
skia, so it was important to make sure that the compositor was done consuming it
before throwing the texture into the recycle bin to prevent read/write race
between contexts. In this case you are just deleting the resource in the current
context, which is equivalent to decrementing a ref count.  In theory you
wouldn't even need to wait for mailboxReleased to delete the texture because you
are not even accessing it from the main thread context after prepareMailbox.

+            }
+
+            WebGraphicsContext3D* webContext = context();
+            GLenum target = GC3D_TEXTURE_RECTANGLE_ARB;

[Justin Novosad, 2016/03/02 16:33:45]

Does the extension for this need to be detected?

+            webContext->bindTexture(target, releasedMailboxInfo->m_textureId);
+            webContext->releaseTexImage2DCHROMIUM(target, releasedMailboxInfo->m_CHROMIUMImageId);
+            webContext->destroyImageCHROMIUM(releasedMailboxInfo->m_CHROMIUMImageId);
+            webContext->deleteTexture(releasedMailboxInfo->m_textureId);
+            webContext->bindTexture(target, 0);
+
+            // Because we are changing the texture binding without going through skia,
+            // we must dirty the context.
+            GrContext* grContext = m_contextProvider->grContext();
+            grContext->resetContext(kTextureBinding_GrGLBackendState);
+        }
     }
 
     RefPtr<Canvas2DLayerBridge> selfRef;
     if (m_destructionInProgress) {
         // To avoid memory use after free, take a scoped self-reference
         // to postpone destruction until the end of this function.
         selfRef = this;
     }
 
     // The destruction of 'releasedMailboxInfo' will:
@@ skipping 92 matching lines @@
 void Canvas2DLayerBridge::willOverwriteCanvas()
 {
     skipQueuedDrawCommands();
 }
 
 Canvas2DLayerBridge::MailboxInfo::MailboxInfo(const MailboxInfo& other)
 {
     memcpy(&m_mailbox, &other.m_mailbox, sizeof(m_mailbox));
     m_image = other.m_image;
     m_parentLayerBridge = other.m_parentLayerBridge;
+    m_CHROMIUMImageId = other.m_CHROMIUMImageId;
+    m_textureId = other.m_textureId;
 }
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(HibernationEvent event)
 {
     DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram, ("Canvas.HibernationEvents", HibernationEventCount));
     hibernationHistogram.count(event);
 }
 
 } // namespace blink