Implement transferToImageBitmap() in WebGLRenderingContext

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

 /*
  * Copyright (C) 2009 Apple 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
@@ skipping 74 matching lines @@
 #include "platform/CheckedInt.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #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"
 #include "wtf/text/StringUTF8Adaptor.h"
 #include "wtf/typed_arrays/ArrayBufferContents.h"
 
 #include <memory>
 
 namespace blink {
 
@@ skipping 522 matching lines @@
 PassOwnPtr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProvider(ScriptState* scriptState, WebGLContextAttributes attributes, unsigned webGLVersion)
 {
     return createContextProviderInternal(nullptr, scriptState, attributes, webGLVersion);
 }
 
 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
 static const GLenum kSupportedInternalFormatsES2[] = {
     GL_RGB,
     GL_RGBA,
     GL_LUMINANCE_ALPHA,
     GL_LUMINANCE,
     GL_ALPHA,
 };
@@ skipping 511 matching lines @@
     m_drawingBuffer.clear();
 }
 
 void WebGLRenderingContextBase::markContextChanged(ContentChangeType changeType)
 {
     if (m_framebufferBinding || isContextLost())
         return;
 
     drawingBuffer()->markContentsChanged();
 
+    if (!canvas())
+        return;
+
     LayoutBox* layoutBox = canvas()->layoutBox();
     if (layoutBox && layoutBox->hasAcceleratedCompositing()) {
         m_markedCanvasDirty = true;
         canvas()->clearCopiedImage();
         layoutBox->contentChanged(changeType);
     } else {
         if (!m_markedCanvasDirty) {
             m_markedCanvasDirty = true;
             canvas()->didDraw(FloatRect(FloatPoint(0, 0), FloatSize(clampedCanvasSize())));
         }
@@ skipping 5206 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink