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::isTextureBacked()
+{
+    return m_image && m_image->isTextureBacked();
+}
+
 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::switchStorageToSkImage(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);
     GrGLTextureInfo textureInfo;
     textureInfo.fTarget = GL_TEXTURE_2D;
-    textureInfo.fID = textureId;
+    textureInfo.fID = m_textureId;
     GrBackendTextureDesc backendTexture;
-    backendTexture.fOrigin = kBottomLeft_GrSurfaceOrigin;
+    // backendTexture.fOrigin = kBottomLeft_GrSurfaceOrigin;
+    backendTexture.fOrigin = kTopLeft_GrSurfaceOrigin;
     backendTexture.fWidth = m_mailbox.textureSize.width;
     backendTexture.fHeight = m_mailbox.textureSize.height;
-    backendTexture.fConfig = kSkia8888_GrPixelConfig;
+    // backendTexture.fConfig = kSkia8888_GrPixelConfig;
+    backendTexture.fConfig = kRGBA_8888_GrPixelConfig;
     backendTexture.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(textureInfo);
     sk_sp<SkImage> skImage = SkImage::MakeFromAdoptedTexture(grContext, backendTexture);
     m_image = fromSkSp(skImage);
+}
+
+void StaticBitmapImage::copyToTexture(WebGraphicsContext3DProvider* provider, GLuint destinationTexture, GLenum internalFormat, GLenum destType)
+{
+    gpu::gles2::GLES2Interface* gl = provider->contextGL();
+    if (!gl)
+        return;
+    gl->CopyTextureCHROMIUM(m_textureId, destinationTexture, internalFormat, destType, false, false, false);
+    const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM();
+    GLbyte syncToken[24];
+    gl->GenSyncTokenCHROMIUM(fenceSync, syncToken);
+}
+
+bool StaticBitmapImage::switchStorageToMailbox(WebGraphicsContext3DProvider* provider)
+{
+    m_mailbox.textureSize = WebSize(m_image->width(), m_image->height());
+    GrContext* grContext = provider->grContext();
+    if (!grContext)
+        return false;
+    grContext->flush();
+    m_mailbox.textureTarget = GL_TEXTURE_2D;
+    gpu::gles2::GLES2Interface* gl = provider->contextGL();
+    if (!gl)
+        return false;
+    GLuint textureID = skia::GrBackendObjectToGrGLTextureInfo(m_image->getTextureHandle(true))->fID;
+    gl->BindTexture(GL_TEXTURE_2D, textureID);
+
+    gl->GenMailboxCHROMIUM(m_mailbox.name);
+    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);
+    m_image = nullptr;
+    return true;
+}
+
+PassRefPtr<SkImage> StaticBitmapImage::imageForCurrentFrame(WebGraphicsContext3DProvider* contextProvider)
+{
+    if (m_image) {
+        // If the SkImage is not texture-backed
+        if (!m_image->isTextureBacked())
+            return m_image;
+        // SkImage is texture-backed, but no mailbox exists. virtual/gpu/ cases.
+        if (!hasMailbox()) {
+            // SkImage is texture-backed on the shared context
+            if (contextProvider) {

[xidachen, 2016/06/14 18:09:40]

bsalomon@: in a layout test that runs on GPU, it creates a SkImage by calling
Blink::Image::imageForCurrentFrame(), and that SkImage is texture-backed. When
WebGL's texImage2D tries to consume this SkImage, it goes through this code
path. What I have found is that if I change:
backendTexture.fOrigin = kBottomLeft_GrSurfaceOrigin;
to backendTexture.fOrigin = kTopLeft_GrSurfaceOrigin;
in the function switchStorageToSkImage(), the result of copyToTexture() doesn't
change at all.

[bsalomon, 2016/06/14 18:25:22]

From what I can tell copyToTexture doesn't look at the SkImage's texture's
origin. Skia doesn't copy the the texture to flip it. The GrTexture's origin is
only seen by Skia and is used when Skia reads the image. It affects the texture
coordinates that we use to access the texture, but only in draws issued by Skia.
Changing the texture origin won't affect copyToTexture's behavior.

+                OwnPtr<WebGraphicsContext3DProvider> sharedProvider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
+                if (!switchStorageToMailbox(sharedProvider.get()))
+                    return nullptr;
+                switchStorageToSkImage(contextProvider);
+                RefPtr<SkImage> retVal = m_image;
+                // Get a new mailbox because we cannot retain a texture in the WebGL context.

[xidachen, 2016/06/14 18:09:41]

junov@: I tried to inject a readPixels() call to the m_image and I can see that
all the pixels are as expected. But after calling the copyToTexture(), the
result that drawing to canvas is flipY version of expected result. I don't know
what is going on...

+                if (!switchStorageToMailbox(contextProvider))
+                    return nullptr;
+                return retVal;
+            }
+            return m_image;
+        }
+        // Has mailbox, but contextProvider is null (2D).
+        if (!contextProvider)
+            return m_image;
+        // 3D context, consume mailbox, prepare a new mailbox.
+        switchStorageToSkImage(contextProvider);
+        RefPtr<SkImage> retVal = m_image;
+        if (!switchStorageToMailbox(contextProvider))
+            return nullptr;
+        return retVal;
+    }
+    // No mailbox, return null;
+    if (!hasMailbox())
+        return nullptr;
+    // Has mailbox, consume mailbox, prepare a new mailbox if contextProvider is not null (3D).
+    if (!contextProvider) {
+        DCHECK(isMainThread());
+        // TODO(xidachen): make this work on a worker thread.
+        OwnPtr<WebGraphicsContext3DProvider> sharedProvider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
+        switchStorageToSkImage(sharedProvider.get());
+    } else {
+        switchStorageToSkImage(contextProvider);
+        RefPtr<SkImage> retVal = m_image;
+        if (!switchStorageToMailbox(contextProvider))
+            return nullptr;
+        return retVal;
+    }
     return m_image;
 }
 
 } // namespace blink