Make DrawingBuffer and Canvas2DLayerBridge be cc::TextureLayerClients.

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
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, 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 "platform/graphics/Canvas2DLayerBridge.h"
 
+#include "base/memory/ptr_util.h"
+#include "cc/resources/single_release_callback.h"
+#include "cc/resources/texture_mailbox.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/graphics/CanvasMetrics.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/gpu/SharedContextRateLimiter.h"
 #include "public/platform/Platform.h"
@@ skipping 149 matching lines @@
     // a 'PreferAcceleration' operation.
     return shouldAccelerate(PreferAcceleration);
 }
 
 GLenum Canvas2DLayerBridge::getGLFilter()
 {
     return m_filterQuality == kNone_SkFilterQuality ? GL_NEAREST : GL_LINEAR;
 }
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
-bool Canvas2DLayerBridge::prepareIOSurfaceMailboxFromImage(SkImage* image, WebExternalTextureMailbox* outMailbox)
+bool Canvas2DLayerBridge::prepareIOSurfaceMailboxFromImage(SkImage* image, cc::TextureMailbox* outMailbox)
 {
     // Need to flush skia's internal queue because texture is about to be accessed directly
     GrContext* grContext = m_contextProvider->grContext();
     grContext->flush();
 
     ImageInfo imageInfo = createIOSurfaceBackedTexture();
     if (imageInfo.empty())
         return false;
 
     gpu::gles2::GLES2Interface* gl = contextGL();
     if (!gl)
         return false;
 
     GLuint imageTexture = skia::GrBackendObjectToGrGLTextureInfo(image->getTextureHandle(true))->fID;
     gl->CopySubTextureCHROMIUM(imageTexture, imageInfo.m_textureId, 0, 0, 0, 0, m_size.width(), m_size.height(), GL_FALSE, GL_FALSE, GL_FALSE);
 
     MailboxInfo& info = m_mailboxes.first();
-    info.m_mailbox.textureTarget = GC3D_TEXTURE_RECTANGLE_ARB;
-    gl->GenMailboxCHROMIUM(info.m_mailbox.name);
-    gl->ProduceTextureDirectCHROMIUM(imageInfo.m_textureId, info.m_mailbox.textureTarget, info.m_mailbox.name);
-    info.m_mailbox.allowOverlay = true;
+    uint32_t textureTarget = GC3D_TEXTURE_RECTANGLE_ARB;
+    gpu::Mailbox mailbox;
+    gl->GenMailboxCHROMIUM(mailbox.name);
+    gl->ProduceTextureDirectCHROMIUM(imageInfo.m_textureId, textureTarget, mailbox.name);
 
     const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM();
     gl->Flush();
-    gl->GenSyncTokenCHROMIUM(fenceSync, info.m_mailbox.syncToken);
-    info.m_mailbox.validSyncToken = true;
+    gpu::SyncToken syncToken;
+    gl->GenSyncTokenCHROMIUM(fenceSync, syncToken.GetData());
 
     info.m_imageInfo = imageInfo;
-    *outMailbox = info.m_mailbox;
+    bool isOverlayCandidate = true;
+    bool secureOutputOnly = false;
+    info.m_mailbox = mailbox;
+    *outMailbox = cc::TextureMailbox(mailbox, syncToken, textureTarget, gfx::Size(m_size.width(), m_size.height()), isOverlayCandidate, secureOutputOnly);
 
     gl->BindTexture(GC3D_TEXTURE_RECTANGLE_ARB, 0);
 
     // Because we are changing the texture binding without going through skia,
     // we must dirty the context.
     grContext->resetContext(kTextureBinding_GrGLBackendState);
 
     return true;
 }
 
@@ skipping 51 matching lines @@
 }
 #endif // USE_IOSURFACE_FOR_2D_CANVAS
 
 void Canvas2DLayerBridge::createMailboxInfo()
 {
     MailboxInfo tmp;
     tmp.m_parentLayerBridge = this;
     m_mailboxes.prepend(tmp);
 }
 
-bool Canvas2DLayerBridge::prepareMailboxFromImage(PassRefPtr<SkImage> image, WebExternalTextureMailbox* outMailbox)
+bool Canvas2DLayerBridge::prepareMailboxFromImage(PassRefPtr<SkImage> image,
+    cc::TextureMailbox* outMailbox)
 {
     createMailboxInfo();
     MailboxInfo& mailboxInfo = m_mailboxes.first();
-    mailboxInfo.m_mailbox.nearestNeighbor = getGLFilter() == GL_NEAREST;
-    mailboxInfo.m_mailbox.textureSize = WebSize(m_size.width(), m_size.height());
 
     GrContext* grContext = m_contextProvider->grContext();
     if (!grContext) {
         mailboxInfo.m_image = image;
         return true; // for testing: skip gl stuff when using a mock graphics context.
     }
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
     if (RuntimeEnabledFeatures::canvas2dImageChromiumEnabled()) {
         if (prepareIOSurfaceMailboxFromImage(image.get(), outMailbox))
             return true;
         // Note: if IOSurface backed texture creation failed we fall back to the
         // non-IOSurface path.
     }
 #endif // USE_IOSURFACE_FOR_2D_CANVAS
 
     mailboxInfo.m_image = image;
 
     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
     // the state cached in skia so that the deferred copy on write
     // in SkSurface_Gpu does not make any false assumptions.
     mailboxInfo.m_image->getTexture()->textureParamsModified();
-    mailboxInfo.m_mailbox.textureTarget = GL_TEXTURE_2D;
 
     gpu::gles2::GLES2Interface* gl = contextGL();
     if (!gl)
         return false;
 
     GLuint textureID = skia::GrBackendObjectToGrGLTextureInfo(mailboxInfo.m_image->getTextureHandle(true))->fID;
     gl->BindTexture(GL_TEXTURE_2D, textureID);
     gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, getGLFilter());
     gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, getGLFilter());
     gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
-    gl->GenMailboxCHROMIUM(mailboxInfo.m_mailbox.name);
-    gl->ProduceTextureCHROMIUM(GL_TEXTURE_2D, mailboxInfo.m_mailbox.name);
+    gpu::Mailbox mailbox;
+    gl->GenMailboxCHROMIUM(mailbox.name);
+    gl->ProduceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
 
+    gpu::SyncToken syncToken;
     if (isHidden()) {
         // With hidden canvases, we release the SkImage immediately because
         // there is no need for animations to be double buffered.
         mailboxInfo.m_image.clear();
     } else {
         // FIXME: We'd rather insert a syncpoint than perform a flush here,
         // but currently the canvas will flicker if we don't flush here.
         const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM();
         gl->Flush();
-        gl->GenSyncTokenCHROMIUM(fenceSync, mailboxInfo.m_mailbox.syncToken);
-        mailboxInfo.m_mailbox.validSyncToken = true;
+        gl->GenSyncTokenCHROMIUM(fenceSync, syncToken.GetData());
     }
+    mailboxInfo.m_mailbox = mailbox;
+    *outMailbox = cc::TextureMailbox(mailbox, syncToken, GL_TEXTURE_2D);
+
     gl->BindTexture(GL_TEXTURE_2D, 0);
     // Because we are changing the texture binding without going through skia,
     // we must dirty the context.
     grContext->resetContext(kTextureBinding_GrGLBackendState);
-
-    *outMailbox = mailboxInfo.m_mailbox;
     return true;
 }
 
 void Canvas2DLayerBridge::resetSkiaTextureBinding()
 {
     GrContext* grContext = m_contextProvider->grContext();
     if (grContext)
         grContext->resetContext(kTextureBinding_GrGLBackendState);
 }
 
@@ skipping 382 matching lines @@
             m_surface = surface.release();
             // FIXME: draw sad canvas picture into new buffer crbug.com/243842
         }
     }
     if (m_imageBuffer)
         m_imageBuffer->updateGPUMemoryUsage();
 
     return m_surface.get();
 }
 
-bool Canvas2DLayerBridge::prepareMailbox(WebExternalTextureMailbox* outMailbox, WebExternalBitmap* bitmap)
+bool Canvas2DLayerBridge::PrepareTextureMailbox(
+    cc::TextureMailbox* outMailbox,
+    std::unique_ptr<cc::SingleReleaseCallback>* outReleaseCallback,
+    bool useSharedMemory)
 {
     if (m_destructionInProgress) {
         // It can be hit in the following sequence.
         // 1. Canvas draws something.
         // 2. The compositor begins the frame.
         // 3. Javascript makes a context be lost.
         // 4. Here.
         return false;
     }
     DCHECK(isAccelerated() || isHibernating() || m_softwareRenderingWhileHidden);
 
     // if hibernating but not hidden, we want to wake up from
     // hibernation
     if ((isHibernating() || m_softwareRenderingWhileHidden) && isHidden())
         return false;
 
-    if (bitmap) {
-        // Using accelerated 2d canvas with software renderer, which
-        // should only happen in tests that use fake graphics contexts
-        // or in Android WebView in software mode. In this case, we do
-        // not care about producing any results for this canvas.
-        skipQueuedDrawCommands();
-        m_lastImageId = 0;
+    // TODO(danakj): This means the compositor has dropped to software
+    // compositing. Our context should already be lost if cc can't make a
+    // context that it can use (each time it tries it loses our context).
+    // But checkSurfaceValid() returns true even tho there is a GL error
+    // sometimes.. so not sure if just checking for a GL error is right here
+    // or what.
+    if (useSharedMemory) {
+        // Since we're going to software compositing, this class will soon be
+        // destroyed for software mode canvas.
         return false;
     }
 
     RefPtr<SkImage> image = newImageSnapshot(PreferAcceleration, SnapshotReasonUnknown);
     if (!image || !image->getTexture())
         return false;
 
     // Early exit if canvas was not drawn to since last prepareMailbox.
     GLenum filter = getGLFilter();
     if (image->uniqueID() == m_lastImageId && filter == m_lastFilter)
         return false;
     m_lastImageId = image->uniqueID();
     m_lastFilter = filter;
 
-    return prepareMailboxFromImage(image.release(), outMailbox);
+    if (!prepareMailboxFromImage(image.release(), outMailbox))
+        return false;
+    outMailbox->set_nearest_neighbor(getGLFilter() == GL_NEAREST);
+
+    auto func = WTF::bind(&Canvas2DLayerBridge::mailboxReleased,
+        m_weakPtrFactory.createWeakPtr(),
+        outMailbox->mailbox());
+    *outReleaseCallback = cc::SingleReleaseCallback::Create(
+        convertToBaseCallback(std::move(func)));
+    return true;
 }
 
-void Canvas2DLayerBridge::mailboxReleased(const WebExternalTextureMailbox& mailbox, bool lostResource)
+void Canvas2DLayerBridge::mailboxReleased(const gpu::Mailbox& mailbox,
+    const gpu::SyncToken& syncToken,
+    bool lostResource)
 {
     DCHECK(isAccelerated() || isHibernating());
     bool contextLost = !isHibernating() && (!m_surface || m_contextProvider->contextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR);
     DCHECK(m_mailboxes.last().m_parentLayerBridge.get() == this);
 
     // Mailboxes are typically released in FIFO order, so we iterate
     // from the end of m_mailboxes.
     auto releasedMailboxInfo = m_mailboxes.end();
     auto firstMailbox = m_mailboxes.begin();
 
     while (true) {
         --releasedMailboxInfo;
-        if (nameEquals(releasedMailboxInfo->m_mailbox, mailbox)) {
+        if (releasedMailboxInfo->m_mailbox == mailbox)
             break;
-        }
         DCHECK(releasedMailboxInfo != firstMailbox);
     }
 
     if (!contextLost) {
         // Invalidate texture state in case the compositor altered it since the copy-on-write.
         if (releasedMailboxInfo->m_image) {
 #if USE_IOSURFACE_FOR_2D_CANVAS
             DCHECK(releasedMailboxInfo->m_imageInfo.empty());
 #endif // USE_IOSURFACE_FOR_2D_CANVAS
-            if (mailbox.validSyncToken) {
-                contextGL()->WaitSyncTokenCHROMIUM(mailbox.syncToken);
+            if (syncToken.HasData()) {
+                contextGL()->WaitSyncTokenCHROMIUM(syncToken.GetConstData());
             }
             GrTexture* texture = releasedMailboxInfo->m_image->getTexture();
             if (texture) {
                 if (lostResource) {
                     texture->abandon();
                 } else {
                     texture->textureParamsModified();
                     // Break the mailbox association to avoid leaking mailboxes every time skia recycles a texture.
                     gpu::gles2::GLES2Interface* gl = contextGL();
                     if (gl)
@@ skipping 125 matching lines @@
     DCHECK(imageId);
     DCHECK(textureId);
 }
 
 bool Canvas2DLayerBridge::ImageInfo::empty()
 {
     return m_imageId == 0;
 }
 #endif // USE_IOSURFACE_FOR_2D_CANVAS
 
-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;
-#if USE_IOSURFACE_FOR_2D_CANVAS
-    m_imageInfo = other.m_imageInfo;
-#endif // USE_IOSURFACE_FOR_2D_CANVAS
-}
+Canvas2DLayerBridge::MailboxInfo::MailboxInfo() = default;
+Canvas2DLayerBridge::MailboxInfo::MailboxInfo(const MailboxInfo& other) = default;
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(HibernationEvent event)
 {
     DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram, ("Canvas.HibernationEvents", HibernationEventCount));
     hibernationHistogram.count(event);
 }
 
 } // namespace blink