Avoid GPU readback in tex(Sub)Image2D(ImageBitmap)

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/StaticBitmapImage.h"
 
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageObserver.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkShader.h"
+#include "third_party/skia/include/gpu/GrContext.h"
 
 namespace blink {
 
 PassRefPtr<StaticBitmapImage> StaticBitmapImage::create(PassRefPtr<SkImage> image)
 {
     if (!image)
         return nullptr;
     return adoptRef(new StaticBitmapImage(image));
 }
 
 PassRefPtr<StaticBitmapImage> StaticBitmapImage::create(WebExternalTextureMailbox& mailbox)
 {
     return adoptRef(new StaticBitmapImage(mailbox));
 }
 
 StaticBitmapImage::StaticBitmapImage(PassRefPtr<SkImage> image) : m_image(image)
 {
     ASSERT(m_image);
 }
 
 StaticBitmapImage::StaticBitmapImage(WebExternalTextureMailbox& mailbox) : m_mailbox(mailbox)
 {
 }
 
 StaticBitmapImage::~StaticBitmapImage() { }
 
 IntSize StaticBitmapImage::size() const
 {
+    if (!m_image)
+        return IntSize(m_mailbox.textureSize.width, m_mailbox.textureSize.height);
     return IntSize(m_image->width(), m_image->height());
 }
 
 bool StaticBitmapImage::currentFrameKnownToBeOpaque(MetadataMode)
 {
     return m_image->isOpaque();
 }
 
 void StaticBitmapImage::draw(SkCanvas* canvas, const SkPaint& paint, const FloatRect& dstRect,
     const FloatRect& srcRect, RespectImageOrientationEnum, ImageClampingMode clampMode)
 {
     FloatRect adjustedSrcRect = srcRect;
     adjustedSrcRect.intersect(SkRect::Make(m_image->bounds()));
 
     if (dstRect.isEmpty() || adjustedSrcRect.isEmpty())
         return; // Nothing to draw.
 
     canvas->drawImageRect(m_image.get(), adjustedSrcRect, dstRect, &paint,
         WebCoreClampingModeToSkiaRectConstraint(clampMode));
 
     if (ImageObserver* observer = getImageObserver())
         observer->didDraw(this);
 }
 
-PassRefPtr<SkImage> StaticBitmapImage::imageForCurrentFrame()
+void StaticBitmapImage::consumeTextureMailbox(WebGraphicsContext3DProvider* provider)
 {
-    if (m_image)
-        return m_image;
-    DCHECK(isMainThread());
-    // In the place when we consume an ImageBitmap that is gpu texture backed,
-    // create a new SkImage from that texture.
-    // TODO(xidachen): make this work on a worker thread.
-    OwnPtr<WebGraphicsContext3DProvider> provider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
     if (!provider)
-        return nullptr;
+        return;
     GrContext* grContext = provider->grContext();
     if (!grContext)
-        return nullptr;
+        return;
     gpu::gles2::GLES2Interface* gl = provider->contextGL();
     if (!gl)
-        return nullptr;
+        return;
     gl->WaitSyncTokenCHROMIUM(m_mailbox.syncToken);
-    GLuint textureId = gl->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, m_mailbox.name);
+    m_textureId = gl->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, m_mailbox.name);

[Ken Russell (switch to Gerrit), 2016/06/01 22:55:09]

Is it legal to cache this value in StaticBitmapImage? What happens if the same
ImageBitmap is uploaded to two different WebGL contexts as textures? The
m_textureId will be unknown in the second context.

If there is a bug here, could you please add a WebGL conformance test for it?

[xidachen, 2016/06/02 13:52:52]

I re-organized the structure of the imageForCurrentFrame() in this class in the
new patch.

In the case when an ImageBitmap is created by WebGL's transferToImageBitmap, it
has a mailbox, and no cached SkImage. Now when this ImageBitmap is consumed by
texImage, it will call this consumeTextureMailbox() function which cache this
textureId, this textureId is used in copyTexture() only. When this ImageBitmap
is consumed by a different WebGL context, it will again go through the code path
of consumeTextureMailbox()-->copyTexture(). Notice that the
consumeTextureMailbox() will change the cached textureId.

Also, here is all the cases in the imageForCurrentFrame() function. Please let
me know if I misunderstand anything.
1. If there is no cached SkImage, which means just a mailbox, and the consumer
of this ImageBitmap is null (2D and bitmaprenderer), use the shared context3D
provider to consume the mailbox which will generate a SkImage, cache that shared
context3D provider and cache the generated SkImage.
2. If no cached SkImage (just a mailbox), and the consumer is a WebGL context,
use the WebGL's context provider to consume the mailbox which generates a
SkImage, cache the SkImage but don't cache the context provider.
3. If there is a cached SkImage and it is not texture backed, return that
SkImage right away.
4. If there is a cached SkImage and the consumer is null (2D or bitmaprenderer),
return that SkImage right away.
5. If there is a cached SkImage and the consumer is a WebGL context, it has 2
sub-cases. If there is no cached context3D provider, then consume the mailbox
which generates a new SkImage, cache the SkImage and don't cache the provider.
The second case is that there is a cached context3D provider, then prepare a new
mailbox, and consume the new mailbox.

Does the above categorization make sense?

     GrGLTextureInfo textureInfo;
     textureInfo.fTarget = GL_TEXTURE_2D;
-    textureInfo.fID = textureId;
+    textureInfo.fID = m_textureId;
     GrBackendTextureDesc backendTexture;
     backendTexture.fOrigin = kBottomLeft_GrSurfaceOrigin;
     backendTexture.fWidth = m_mailbox.textureSize.width;
     backendTexture.fHeight = m_mailbox.textureSize.height;
     backendTexture.fConfig = kSkia8888_GrPixelConfig;
     backendTexture.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(textureInfo);
     sk_sp<SkImage> skImage = SkImage::MakeFromAdoptedTexture(grContext, backendTexture);
     m_image = fromSkSp(skImage);
+}
+
+void StaticBitmapImage::copyTexture(WebGraphicsContext3DProvider* provider, GLuint texture, GLenum internalFormat, GLenum destType)
+{
+    gpu::gles2::GLES2Interface* gl = provider->contextGL();
+    if (!gl)
+        return;
+    gl->CopyTextureCHROMIUM(m_textureId, texture, internalFormat, destType, false, false, false);
+    const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM();
+    gl->Flush();
+    GLbyte syncToken[24];
+    gl->GenSyncTokenCHROMIUM(fenceSync, syncToken);
+}
+
+bool StaticBitmapImage::prepareMailboxForSkImage(WebGraphicsContext3DProvider* provider)
+{
+    m_mailbox.textureSize = WebSize(m_image->width(), m_image->height());
+    GrContext* grContext = m_provider->grContext();
+    if (!grContext)
+        return false;
+    grContext->flush();
+    m_image->getTexture()->textureParamsModified();
+    m_mailbox.textureTarget = GL_TEXTURE_2D;
+    gpu::gles2::GLES2Interface* gl = m_provider->contextGL();
+    if (!gl)
+        return false;
+    GLuint textureID = skia::GrBackendObjectToGrGLTextureInfo(m_image->getTextureHandle(true))->fID;
+    gl->BindTexture(GL_TEXTURE_2D, textureID);
+
+    // Re-use the texture's existing mailbox, if there is one.
+    if (m_image->getTexture()->getCustomData()) {
+        DCHECK(m_image->getTexture()->getCustomData()->size() == sizeof(m_mailbox.name));
+        memcpy(&m_mailbox.name[0], m_image->getTexture()->getCustomData()->data(), sizeof(m_mailbox.name));
+    } else {
+        gl->GenMailboxCHROMIUM(m_mailbox.name);
+        RefPtr<SkData> mailboxNameData = adoptRef(SkData::NewWithCopy(&m_mailbox.name[0], sizeof(m_mailbox.name)));
+        m_image->getTexture()->setCustomData(mailboxNameData.get());
+        gl->ProduceTextureCHROMIUM(GL_TEXTURE_2D, m_mailbox.name);
+    }
+    const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM();
+    gl->Flush();
+    gl->GenSyncTokenCHROMIUM(fenceSync, m_mailbox.syncToken);
+    m_mailbox.validSyncToken = true;
+    gl->BindTexture(GL_TEXTURE_2D, 0);
+    grContext->resetContext(kTextureBinding_GrGLBackendState);
+    return true;
+}
+
+// There are four cases depending on whether m_image == nullptr && contextProvider == nullptr.
+PassRefPtr<SkImage> StaticBitmapImage::imageForCurrentFrame(WebGraphicsContext3DProvider* contextProvider)
+{
+    if (m_image && (!m_image->isTextureBacked() || !contextProvider || !m_provider))
+        return m_image;
+    if (!m_image) {
+        if (!contextProvider) {
+            DCHECK(isMainThread());
+            // TODO(xidachen): make this work on a worker thread.
+            OwnPtr<WebGraphicsContext3DProvider> provider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
+            consumeTextureMailbox(provider.get());
+            m_provider = std::move(provider);
+        } else {
+            consumeTextureMailbox(contextProvider);
+        }
+        return m_image;
+    }
+    if (!prepareMailboxForSkImage(contextProvider))
+        return m_image;
+    consumeTextureMailbox(contextProvider);
     return m_image;
 }
 
 } // namespace blink