Implement transferToImageBitmap() in WebGLRenderingContext

third_party/WebKit/Source/modules/webgl/WebGLRenderingContext.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 67 matching lines @@
     if (extensionsUtil->supportsExtension("GL_EXT_debug_marker")) {
         String contextLabel(String::format("WebGLRenderingContext-%p", contextProvider));
         gl->PushGroupMarkerEXT(0, contextLabel.ascii().data());
     }
     return true;
 }
 
 CanvasRenderingContext* WebGLRenderingContext::Factory::create(ScriptState* scriptState, OffscreenCanvas* offscreenCanvas, const CanvasContextCreationAttributes& attrs)
 {
     WebGLContextAttributes attributes = toWebGLContextAttributes(attrs);
+    // transferToImageBitmap calls paintRenderingResultsToImageData, which
+    // requires this bit to be false;
+    attributes.setPremultipliedAlpha(false);

[Ken Russell (switch to Gerrit), 2016/05/10 23:11:42]

I don't think it's legal to just set this all the time for WebGL contexts. It
will break rendering of certain applications which assume the compositor and the
WebGL app behave in a certain way. Unfortunately, I don't think this is or can
be covered by a WebGL conformance test, but we should add a reference test that
verifies the behavior of premultipliedAlpha:true and false for WebGL-rendered
canvases. Can you help with that or should I write them?

[xidachen, 2016/05/11 00:17:52]

I did hesitate when I added this statement. The only reason I put it here is
that there is a "ASSERT(!m_premultipliedAlpha);" in the method
DrawingBuffer::paintRenderingResultsToImageData. So without this line, I am
always hitting that ASSERT. Is there a way to avoid hitting that ASSERT without
setting false here? I'd like to remove this like we can avoid that ASSERT.

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

It's likely that that code path has never been tested, and that the assertion
was merely put in place to force re-evaluation of the code if anyone hit it.

This code path would probably take effect if someone called toDataURL() on a
WebGL-rendered canvas where the context was created with premultiplyAlpha:true.
Also, clearly, your new code is hitting it.

In order to generalize it, a lossy "unmultiplication" of the alpha channel would
have to be done during the readback. Thinking about it, something like this must
be being done for 2D canvas when fetching the ImageData for the backing store.
Can you talk with junov@ and confirm?

In some sense, there's no problem with adding support for AlphaDoUnmultiply in
DrawingBuffer::readBackFramebuffer -- but if we do this, we need to add tests.

Alternatively, we could work on implementing this the right way, and avoid the
readbacks entirely when creating the ImageBitmap.

[xidachen, 2016/05/11 01:07:08]

Yeah, it makes more sense to implement this using another approach. I just took
another look at:
WebGLRenderingContextBase::paintRenderingResultsToImageData
Apparent it returns nullptr when the premultipliedAlpha=true.

     OwnPtr<WebGraphicsContext3DProvider> contextProvider(createWebGraphicsContext3DProvider(scriptState, attributes, 1));
     if (!shouldCreateContext(contextProvider.get()))
         return nullptr;
 
     WebGLRenderingContext* renderingContext = new WebGLRenderingContext(offscreenCanvas, contextProvider.release(), attributes);
     if (!renderingContext->drawingBuffer())
         return nullptr;
     renderingContext->initializeNewContext();
     renderingContext->registerContextExtensions();
 
@@ skipping 42 matching lines @@
     result.setWebGLRenderingContext(this);
 }
 
 void WebGLRenderingContext::setOffscreenCanvasGetContextResult(OffscreenRenderingContext& result)
 {
     result.setWebGLRenderingContext(this);
 }
 
 ImageBitmap* WebGLRenderingContext::transferToImageBitmap(ExceptionState& exceptionState)
 {
-    NOTIMPLEMENTED();
-    return nullptr;
+    return transferToImageBitmapBase();
 }
 
 void WebGLRenderingContext::registerContextExtensions()
 {
     // Register extensions.
     static const char* const bothPrefixes[] = { "", "WEBKIT_", 0, };
 
     registerExtension<ANGLEInstancedArrays>(m_angleInstancedArrays);
     registerExtension<EXTBlendMinMax>(m_extBlendMinMax);
     registerExtension<EXTDisjointTimerQuery>(m_extDisjointTimerQuery);
@@ skipping 43 matching lines @@
     visitor->trace(m_webglCompressedTextureASTC);
     visitor->trace(m_webglCompressedTextureATC);
     visitor->trace(m_webglCompressedTextureETC1);
     visitor->trace(m_webglCompressedTexturePVRTC);
     visitor->trace(m_webglCompressedTextureS3TC);
     visitor->trace(m_webglDepthTexture);
     WebGLRenderingContextBase::trace(visitor);
 }
 
 } // namespace blink