Reland of Allow canvases to be GPU-accelerated in Workers

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

Index: third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp
diff --git a/third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp b/third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp
index c572b79a3a5b4552538ef754a612b11024fea9a7..28b72be0fd4be892ea2765f5bd3bf0ca5b1f087d 100644
--- a/third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp
+++ b/third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp
@@ -6,10 +6,13 @@
 
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/sync_token.h"
+#include "platform/CrossThreadFunctional.h"
 #include "platform/graphics/StaticBitmapImage.h"
+#include "platform/graphics/gpu/SharedGpuContext.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
+#include "public/platform/WebTaskRunner.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/gpu/GrContext.h"
@@ -20,37 +23,50 @@
 
 namespace blink {
 
-PassRefPtr<AcceleratedStaticBitmapImage> AcceleratedStaticBitmapImage::create(sk_sp<SkImage> image)
+PassRefPtr<AcceleratedStaticBitmapImage> AcceleratedStaticBitmapImage::createFromSharedContextImage(sk_sp<SkImage> image)
 {
     return adoptRef(new AcceleratedStaticBitmapImage(std::move(image)));
 }
 
-PassRefPtr<AcceleratedStaticBitmapImage> AcceleratedStaticBitmapImage::create(sk_sp<SkImage> image, sk_sp<GrContext> grContext, const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken)
-{
-    return adoptRef(new AcceleratedStaticBitmapImage(std::move(image), std::move(grContext), mailbox, syncToken));
+PassRefPtr<AcceleratedStaticBitmapImage> AcceleratedStaticBitmapImage::createFromWebGLContextImage(sk_sp<SkImage> image, const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken)
+{
+    return adoptRef(new AcceleratedStaticBitmapImage(std::move(image), mailbox, syncToken));
 }
 
 AcceleratedStaticBitmapImage::AcceleratedStaticBitmapImage(sk_sp<SkImage> image)
     : StaticBitmapImage(std::move(image))
-    , m_imageIsForSharedMainThreadContext(true)
-{
-}
-
-AcceleratedStaticBitmapImage::AcceleratedStaticBitmapImage(sk_sp<SkImage> image, sk_sp<GrContext> grContext, const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken)
+    , m_sharedContextId(SharedGpuContext::contextId())
+{
+    m_threadChecker.DetachFromThread();
+}
+
+AcceleratedStaticBitmapImage::AcceleratedStaticBitmapImage(sk_sp<SkImage> image, const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken)
     : StaticBitmapImage(std::move(image))
-    , m_imageIsForSharedMainThreadContext(false) // TODO(danakj): Could be true though, caller would know.
-    , m_grContext(std::move(grContext))
+    , m_sharedContextId(SharedGpuContext::kNoSharedContext)
     , m_hasMailbox(true)
     , m_mailbox(mailbox)
     , m_syncToken(syncToken)
 {
-    DCHECK(m_grContext);
-}
-
-AcceleratedStaticBitmapImage::~AcceleratedStaticBitmapImage() = default;
+    m_threadChecker.DetachFromThread();
+
+    // Note: In this case, m_image is not usable directly because it is not in the shared context.
+    // It is just used to hold a reference to the texture object in the origin context until the
+    // mailbox can be consumed.
+}
+
+AcceleratedStaticBitmapImage::~AcceleratedStaticBitmapImage()
+{
+    // Avoid leaking mailboxes in cases where the texture gets recycled by skia.
+    if (m_hasMailbox && SharedGpuContext::isValid())
+        SharedGpuContext::gl()->ProduceTextureDirectCHROMIUM(0, GL_TEXTURE_2D, m_mailbox.name);
+    releaseImageThreadSafe();
+}
 
 void AcceleratedStaticBitmapImage::copyToTexture(WebGraphicsContext3DProvider* destProvider, GLuint destTextureId, GLenum internalFormat, GLenum destType, bool flipY)
 {
+    checkThread();
+    if (!isValid())
+        return;
     // |destProvider| may not be the same context as the one used for |m_image| so we use a mailbox to
     // generate a texture id for |destProvider| to access.
     ensureMailbox();
@@ -66,26 +82,49 @@
 
 sk_sp<SkImage> AcceleratedStaticBitmapImage::imageForCurrentFrame()
 {
-    // This must return an SkImage that can be used with the shared main thread context. If |m_image| satisfies that, we are done.
-    if (m_imageIsForSharedMainThreadContext)
-        return m_image;
-
-    // TODO(xidachen): make this work on a worker thread.
-    DCHECK(isMainThread());
-
-    // If the SkImage came from any other context than the shared main thread one, we expect to be given a mailbox at construction. We
-    // use the mailbox to generate a texture id for the shared main thread context to use.
+    checkThread();
+    if (!isValid())
+        return nullptr;
+    createImageFromMailboxIfNeeded();
+    return m_image;
+}
+
+void AcceleratedStaticBitmapImage::draw(SkCanvas* canvas, const SkPaint& paint, const FloatRect& dstRect, const FloatRect& srcRect, RespectImageOrientationEnum respectImageOrientation, ImageClampingMode imageClampingMode)
+{
+    checkThread();
+    if (!isValid())
+        return;
+    createImageFromMailboxIfNeeded();
+    StaticBitmapImage::draw(canvas, paint, dstRect, srcRect, respectImageOrientation, imageClampingMode);
+}
+
+bool AcceleratedStaticBitmapImage::isValid()
+{
+    if (!m_image)
+        return false;
+    if (!SharedGpuContext::isValid())
+        return false; // Gpu context was lost
+    if (imageBelongsToSharedContext() && m_sharedContextId != SharedGpuContext::contextId())
+        return false; // Gpu context was lost an restored since resource was created
+    return true;
+}
+
+bool AcceleratedStaticBitmapImage::imageBelongsToSharedContext()
+{
+    return m_sharedContextId != SharedGpuContext::kNoSharedContext;
+}
+
+void AcceleratedStaticBitmapImage::createImageFromMailboxIfNeeded()
+{
+    if (imageBelongsToSharedContext())
+        return;
     DCHECK(m_hasMailbox);
-
-    auto sharedMainThreadContextProvider = wrapUnique(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
-    gpu::gles2::GLES2Interface* sharedGL = sharedMainThreadContextProvider->contextGL();
-    GrContext* sharedGrContext = sharedMainThreadContextProvider->grContext();
-    if (!sharedGrContext)
-        return nullptr; // Can happen if the context is lost, the SkImage won't be any good now anyway.
+    gpu::gles2::GLES2Interface* sharedGL = SharedGpuContext::gl();
+    GrContext* sharedGrContext = SharedGpuContext::gr();
+    DCHECK(sharedGL && sharedGrContext); // context isValid already checked in callers
 
     sharedGL->WaitSyncTokenCHROMIUM(m_syncToken.GetData());
     GLuint sharedContextTextureId = sharedGL->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, m_mailbox.name);
-
     GrGLTextureInfo textureInfo;
     textureInfo.fTarget = GL_TEXTURE_2D;
     textureInfo.fID = sharedContextTextureId;
@@ -96,11 +135,11 @@
     backendTexture.fConfig = kSkia8888_GrPixelConfig;
     backendTexture.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(textureInfo);
 
-    m_image = SkImage::MakeFromAdoptedTexture(sharedGrContext, backendTexture);
-    m_imageIsForSharedMainThreadContext = true;
-    // Can drop the ref on the GrContext since m_image is now backed by a texture from the shared main thread context.
-    m_grContext = nullptr;
-    return m_image;
+    sk_sp<SkImage> newImage = SkImage::MakeFromAdoptedTexture(sharedGrContext, backendTexture);
+    releaseImageThreadSafe();
+    m_image = newImage;
+
+    m_sharedContextId = SharedGpuContext::contextId();
 }
 
 void AcceleratedStaticBitmapImage::ensureMailbox()
@@ -108,15 +147,12 @@
     if (m_hasMailbox)
         return;
 
-    // If we weren't given a mailbox at creation, then we were given a SkImage that is assumed to be from the shared main thread context.
-    DCHECK(m_imageIsForSharedMainThreadContext);
-    auto sharedMainThreadContextProvider = wrapUnique(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
-
-    gpu::gles2::GLES2Interface* sharedGL = sharedMainThreadContextProvider->contextGL();
-    GrContext* sharedGrContext = sharedMainThreadContextProvider->grContext();
+    DCHECK(m_image);
+
+    gpu::gles2::GLES2Interface* sharedGL = SharedGpuContext::gl();
+    GrContext* sharedGrContext = SharedGpuContext::gr();
     if (!sharedGrContext)
         return; // Can happen if the context is lost, the SkImage won't be any good now anyway.
-
     GLuint imageTextureId = skia::GrBackendObjectToGrGLTextureInfo(m_image->getTextureHandle(true))->fID;
     sharedGL->BindTexture(GL_TEXTURE_2D, imageTextureId);
 
@@ -133,4 +169,49 @@
     m_hasMailbox = true;
 }
 
+void AcceleratedStaticBitmapImage::transfer()
+{
+    checkThread();
+    ensureMailbox();
+    m_sharedContextId = SharedGpuContext::kNoSharedContext;
+    // If image thread is set, it means that the image has been consumed on the current thread,
+    // which may happen when we have chained transfers. When that is the case, we must not
+    // reset m_imageThread to ensure that releaseImage is called on the right thread.
+    if (!m_imageThread)
+        m_imageThread = Platform::current()->currentThread();
+    m_detachThreadAtNextCheck = true;
+}
+
+void AcceleratedStaticBitmapImage::checkThread()
+{
+    if (m_detachThreadAtNextCheck) {
+        m_threadChecker.DetachFromThread();
+        m_detachThreadAtNextCheck = false;
+    }
+    CHECK(m_threadChecker.CalledOnValidThread());
+}
+
+void releaseImage(sk_sp<SkImage>&& image, std::unique_ptr<gpu::SyncToken>&& syncToken)
+{
+    if (SharedGpuContext::isValid() && syncToken->HasData())
+        SharedGpuContext::gl()->WaitSyncTokenCHROMIUM(syncToken->GetData());
+    image.reset();
+}
+
+void AcceleratedStaticBitmapImage::releaseImageThreadSafe()
+{
+    // If m_image belongs to a GrContext that is on another thread, it
+    // must be released on that thread.
+    if (m_imageThread && m_image && m_imageThread != Platform::current()->currentThread() && SharedGpuContext::isValid()) {
+        gpu::gles2::GLES2Interface* sharedGL = SharedGpuContext::gl();
+        std::unique_ptr<gpu::SyncToken> releaseSyncToken(new gpu::SyncToken);
+        const GLuint64 fenceSync = sharedGL->InsertFenceSyncCHROMIUM();
+        sharedGL->Flush();
+        sharedGL->GenSyncTokenCHROMIUM(fenceSync, releaseSyncToken->GetData());
+        m_imageThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, crossThreadBind(&releaseImage, passed(std::move(m_image)), passed(std::move(releaseSyncToken))));
+    }
+    m_image = nullptr;
+    m_imageThread = nullptr;
+}
+
 } // namespace blink