Implement transferToImageBitmap() in WebGLRenderingContext

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

Index: third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp
diff --git a/third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp b/third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp
index fa3c89ad6a4fc331300398ce239e901a47cd533d..e042e922fc2b0b661c3607996983b004ca1edde7 100644
--- a/third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp
+++ b/third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp
@@ -92,6 +92,7 @@
 #include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
 #include "public/platform/Platform.h"
 #include "public/platform/functional/WebFunction.h"
+#include "skia/ext/texture_handle.h"
 #include "wtf/Functional.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/text/StringBuilder.h"
@@ -634,6 +635,29 @@ void WebGLRenderingContextBase::forceNextWebGLContextCreationToFail()
     shouldFailContextCreationForTesting = true;
 }
 
+ImageBitmap* WebGLRenderingContextBase::transferToImageBitmapBase()
+{
+    if (!drawingBuffer())
+        return nullptr;
+    GrContext* grContext = drawingBuffer()->contextProvider()->grContext();
+    if (!grContext)
+        return nullptr;
+    SkAlphaType alphaType = (m_requestedAttributes.premultipliedAlpha()) ? kPremul_SkAlphaType : kOpaque_SkAlphaType;
+    SkImageInfo info = SkImageInfo::MakeN32(drawingBufferWidth(), drawingBufferHeight(), alphaType);
+    SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
+    sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(grContext, SkBudgeted::kYes, info, 0, (m_requestedAttributes.premultipliedAlpha()) ? &disableLCDProps : nullptr);
+    gpu::gles2::GLES2Interface* gl = drawingBuffer()->contextProvider()->contextGL();
+    GLuint textureId = skia::GrBackendObjectToGrGLTextureInfo(surface->getTextureHandle(SkSurface::kDiscardWrite_TextureHandleAccess))->fID;
+    if (!textureId)
+        return nullptr;
+    gl->Flush();
+    if (!(drawingBuffer()->copyToPlatformTexture(gl, textureId, GL_RGBA, GL_UNSIGNED_BYTE, 0, true, false, BackBuffer)))

[xidachen, 2016/05/17 17:02:00]

It turns out that we can consume the texture in here. Basically what I did here
is to create a new SkSurface, give the surface's texture handle to the
copyToPlatformTexture() method. My understanding of copyToPlatformTexture() is
that it transfers texture to the surface via a mailbox. With this, the layout
tests work fine, on both main thread and a worker thread. Using this approach,
we wouldn't have to change anything in the places that consume this ImageBitmap,
would this be acceptable?

[Ken Russell (switch to Gerrit), 2016/05/18 01:20:41]

DrawingBuffer::copyToPlatformTexture, as the name implies, does a copy of the
DrawingBuffer's contents into the given texture ID that is owned by the given
GLES2Interface. This isn't the semantic that is desired. The goal here is to
*give* the texture away, not copy it. Copying, even on the GPU, is expensive.
The DrawingBuffer should need to allocate a new front buffer after calling this
primitive. Further, when the consumer of this ImageBitmap transfers it into the
destination canvas (using ImageBitmapRenderingContext), any texture that was
previously being displayed there will need to go into some recycling pool so
that in the steady state there is no continuous allocation and deletion of
textures.

From previous conversations with reed@ and bsalomon@ I think the primitive you
may want to use is SkImage::MakeFromTexture. This lets you take an
externally-owned texture and feed it into Skia. From there you can use Skia's
APIs against it. However, I don't know in which OpenGL context you will need to
have the texture's ID, for whoever is going to consume the ImageBitmap later. It
might be that which is given by
Platform::current()->createSharedOffscreenGraphicsContext3DProvider() (see
src/third_party/WebKit/Source/platform/graphics/ImageBuffer.cpp). Basically,
it's probably the shared OpenGL context used by all canvases using
ImageBitmapRenderingContext. However, I'm not sure you can reference that
context from the worker thread -- which is why you'd need to transfer the
texture through a mailbox, and add a new constructor for ImageBitmap, taking a
texture mailbox.

[xidachen, 2016/05/18 15:13:36]

Sorry for the delay. I should have used mailbox from the beginning. Please take
a look at the latest patch, which works under both debug and release mode.

+        return nullptr;
+    RefPtr<StaticBitmapImage> image = StaticBitmapImage::create(fromSkSp(surface->makeImageSnapshot()));
+    ImageBitmap* imageBitmap = ImageBitmap::create(image.release());
+    return imageBitmap;
+}
+
 namespace {
 
 // ES2 enums
@@ -1165,6 +1189,9 @@ void WebGLRenderingContextBase::markContextChanged(ContentChangeType changeType)
 
     drawingBuffer()->markContentsChanged();
 
+    if (!canvas())
+        return;
+
     LayoutBox* layoutBox = canvas()->layoutBox();
     if (layoutBox && layoutBox->hasAcceleratedCompositing()) {
         m_markedCanvasDirty = true;