Fix failing transferToImageBitmap layout tests and commit pixel test on Mac

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 950 matching lines @@
     , m_version(version)
 {
     ASSERT(contextProvider);
 
     m_contextGroup = WebGLContextGroup::create();
     m_contextGroup->addContext(this);
 
     m_maxViewportDims[0] = m_maxViewportDims[1] = 0;
     contextProvider->contextGL()->GetIntegerv(GL_MAX_VIEWPORT_DIMS, m_maxViewportDims);
 
-    RefPtr<DrawingBuffer> buffer = createDrawingBuffer(std::move(contextProvider));
+    RefPtr<DrawingBuffer> buffer;
+    if (passedOffscreenCanvas)
+        buffer = createDrawingBuffer(std::move(contextProvider), DrawingBuffer::DisallowChromiumImage);
+    else
+        buffer = createDrawingBuffer(std::move(contextProvider), DrawingBuffer::AllowChromiumImage);
     if (!buffer) {
         m_contextLostMode = SyntheticLostContext;
         return;
     }
 
     m_drawingBuffer = buffer.release();
     m_drawingBuffer->addNewMailboxCallback(WTF::bind(&WebGLRenderingContextBase::notifyCanvasContextChanged, wrapWeakPersistent(this)));
     drawingBuffer()->bind(GL_FRAMEBUFFER);
     setupFlags();
 
 #define ADD_VALUES_TO_SET(set, values) \
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(values); ++i) {   \
         set.insert(values[i]);                         \
     }
 
     ADD_VALUES_TO_SET(m_supportedInternalFormats, kSupportedInternalFormatsES2);
     ADD_VALUES_TO_SET(m_supportedInternalFormatsCopyTexImage, kSupportedInternalFormatsES2);
     ADD_VALUES_TO_SET(m_supportedFormats, kSupportedFormatsES2);
     ADD_VALUES_TO_SET(m_supportedTypes, kSupportedTypesES2);
 }
 
-PassRefPtr<DrawingBuffer> WebGLRenderingContextBase::createDrawingBuffer(std::unique_ptr<WebGraphicsContext3DProvider> contextProvider)
+PassRefPtr<DrawingBuffer> WebGLRenderingContextBase::createDrawingBuffer(std::unique_ptr<WebGraphicsContext3DProvider> contextProvider, DrawingBuffer::ChromiumImageUsage chromiumImageUsage)
 {
     bool premultipliedAlpha = creationAttributes().premultipliedAlpha();
     bool wantAlphaChannel = creationAttributes().alpha();
     bool wantDepthBuffer = creationAttributes().depth();
     bool wantStencilBuffer = creationAttributes().stencil();
     bool wantAntialiasing = creationAttributes().antialias();
     DrawingBuffer::PreserveDrawingBuffer preserve = creationAttributes().preserveDrawingBuffer() ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
     DrawingBuffer::WebGLVersion webGLVersion = DrawingBuffer::WebGL1;
     if (version() == 1) {
         webGLVersion = DrawingBuffer::WebGL1;
     } else if (version() == 2) {
         webGLVersion = DrawingBuffer::WebGL2;
     } else {
         NOTREACHED();
     }
     return DrawingBuffer::create(
         std::move(contextProvider),
         clampedCanvasSize(),
         premultipliedAlpha,
         wantAlphaChannel,
         wantDepthBuffer,
         wantStencilBuffer,
         wantAntialiasing,
         preserve,
-        webGLVersion);
+        webGLVersion,
+        chromiumImageUsage);
 }
 
 void WebGLRenderingContextBase::initializeNewContext()
 {
     ASSERT(!isContextLost());
     ASSERT(drawingBuffer());
 
     m_markedCanvasDirty = false;
     m_activeTextureUnit = 0;
     m_packAlignment = 4;
@@ skipping 5141 matching lines @@
         m_drawingBuffer.clear();
     }
 
     Platform::ContextAttributes attributes = toPlatformContextAttributes(creationAttributes(), version());
     Platform::GraphicsInfo glInfo;
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider = wrapUnique(Platform::current()->createOffscreenGraphicsContext3DProvider(
         attributes, canvas()->document().topDocument().url(), 0, &glInfo));
     RefPtr<DrawingBuffer> buffer;
     if (contextProvider && contextProvider->bindToCurrentThread()) {
         // Construct a new drawing buffer with the new GL context.
-        buffer = createDrawingBuffer(std::move(contextProvider));
+        buffer = createDrawingBuffer(std::move(contextProvider), DrawingBuffer::AllowChromiumImage);

[Ken Russell (switch to Gerrit), 2016/09/26 21:47:19]

Is this correct in all cases, or does the context restoration path need to check
whether this WebGLRenderingContextBase was created for an OffscreenCanvas? It
looks like there are other places in this code that would need to change, too.

I wonder how dispatch of context lost/restored events would work to an
OffscreenCanvas.

The WEBGL_lose_context extension could be used to test this.

It's at least worth a TODO if not a follow-on bug.

         // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is set to null.
     }
     if (!buffer) {
         if (m_contextLostMode == RealLostContext) {
             m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts, BLINK_FROM_HERE);
         } else {
             // This likely shouldn't happen but is the best way to report it to the WebGL app.
             synthesizeGLError(GL_INVALID_OPERATION, "", "error restoring context");
         }
         return;
@@ skipping 282 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(HTMLCanvasElementOrOffscreenCanvas& result) const
 {
     if (canvas())
         result.setHTMLCanvasElement(canvas());
     else
         result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 } // namespace blink