Fix failing transferToImageBitmap layout tests and commit pixel test on Mac

third_party/WebKit/Source/platform/graphics/gpu/DrawingBuffer.cpp

 /*
  * Copyright (c) 2010, Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 72 matching lines @@
     GLuint m_oldTextureUnitZeroId;
 };
 
 static bool shouldFailDrawingBufferCreationForTesting = false;
 
 } // namespace
 
 PassRefPtr<DrawingBuffer> DrawingBuffer::create(std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const IntSize& size, bool premultipliedAlpha, bool wantAlphaChannel,
     bool wantDepthBuffer, bool wantStencilBuffer, bool wantAntialiasing,
-    PreserveDrawingBuffer preserve, WebGLVersion webGLVersion)
+    PreserveDrawingBuffer preserve, WebGLVersion webGLVersion,
+    ChromiumImageUsage chromiumImageUsage)
 {
     ASSERT(contextProvider);
 
     if (shouldFailDrawingBufferCreationForTesting) {
         shouldFailDrawingBufferCreationForTesting = false;
         return nullptr;
     }
 
     std::unique_ptr<Extensions3DUtil> extensionsUtil = Extensions3DUtil::create(contextProvider->contextGL());
     if (!extensionsUtil->isValid()) {
@@ skipping 12 matching lines @@
             extensionsUtil->ensureExtensionEnabled("GL_CHROMIUM_framebuffer_multisample");
         else
             extensionsUtil->ensureExtensionEnabled("GL_EXT_multisampled_render_to_texture");
     }
     bool discardFramebufferSupported = extensionsUtil->supportsExtension("GL_EXT_discard_framebuffer");
     if (discardFramebufferSupported)
         extensionsUtil->ensureExtensionEnabled("GL_EXT_discard_framebuffer");
 
     RefPtr<DrawingBuffer> drawingBuffer = adoptRef(new DrawingBuffer(std::move(contextProvider), std::move(extensionsUtil),
         discardFramebufferSupported, wantAlphaChannel, premultipliedAlpha,
-        preserve, webGLVersion, wantDepthBuffer, wantStencilBuffer));
+        preserve, webGLVersion, wantDepthBuffer, wantStencilBuffer, chromiumImageUsage));
     if (!drawingBuffer->initialize(size, multisampleSupported)) {
         drawingBuffer->beginDestruction();
         return PassRefPtr<DrawingBuffer>();
     }
     return drawingBuffer.release();
 }
 
 void DrawingBuffer::forceNextDrawingBufferCreationToFail()
 {
     shouldFailDrawingBufferCreationForTesting = true;
 }
 
 DrawingBuffer::DrawingBuffer(
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     std::unique_ptr<Extensions3DUtil> extensionsUtil,
     bool discardFramebufferSupported,
     bool wantAlphaChannel,
     bool premultipliedAlpha,
     PreserveDrawingBuffer preserve,
     WebGLVersion webGLVersion,
     bool wantDepth,
-    bool wantStencil)
+    bool wantStencil,
+    ChromiumImageUsage chromiumImageUsage)
     : m_preserveDrawingBuffer(preserve)
     , m_webGLVersion(webGLVersion)
     , m_contextProvider(std::move(contextProvider))
     , m_gl(m_contextProvider->contextGL())
     , m_extensionsUtil(std::move(extensionsUtil))
     , m_discardFramebufferSupported(discardFramebufferSupported)
     , m_wantAlphaChannel(wantAlphaChannel)
     , m_premultipliedAlpha(premultipliedAlpha)
     , m_softwareRendering(m_contextProvider->isSoftwareRendering())
     , m_wantDepth(wantDepth)
     , m_wantStencil(wantStencil)
+    , m_chromiumImageUsage(chromiumImageUsage)
 {
     memset(m_colorMask, 0, 4 * sizeof(GLboolean));
     memset(m_clearColor, 0, 4 * sizeof(GLfloat));
     // Used by browser tests to detect the use of a DrawingBuffer.
     TRACE_EVENT_INSTANT0("test_gpu", "DrawingBufferCreation", TRACE_EVENT_SCOPE_GLOBAL);
 }
 
 DrawingBuffer::~DrawingBuffer()
 {
     ASSERT(m_destructionInProgress);
@@ skipping 55 matching lines @@
     return !m_drawFramebufferBinding && defaultBufferRequiresAlphaChannelToBePreserved();
 }
 
 bool DrawingBuffer::defaultBufferRequiresAlphaChannelToBePreserved()
 {
     if (wantExplicitResolve()) {
         return !m_wantAlphaChannel && getMultisampledRenderbufferFormat() == GL_RGBA8_OES;
     }
 
     bool rgbEmulation = contextProvider()->getCapabilities().emulate_rgb_buffer_with_rgba
-        || (RuntimeEnabledFeatures::webGLImageChromiumEnabled() && contextProvider()->getCapabilities().chromium_image_rgb_emulation);
+        || (shouldUseChromiumImage() && contextProvider()->getCapabilities().chromium_image_rgb_emulation);
     return !m_wantAlphaChannel && rgbEmulation;
 }
 
 void DrawingBuffer::freeRecycledMailboxes()
 {
     while (!m_recycledMailboxQueue.isEmpty()) {
         RefPtr<RecycledMailbox> recycled = m_recycledMailboxQueue.takeLast();
         deleteMailbox(recycled->mailbox, recycled->syncToken);
     }
 }
@@ skipping 283 matching lines @@
 }
 
 PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::takeRecycledMailbox()
 {
     if (m_recycledMailboxQueue.isEmpty())
         return nullptr;
 
     // Creation of image backed mailboxes is very expensive, so be less
     // aggressive about pruning them.
     size_t cacheLimit = 1;
-    if (RuntimeEnabledFeatures::webGLImageChromiumEnabled())
+    if (shouldUseChromiumImage())
         cacheLimit = 4;
 
     RefPtr<RecycledMailbox> recycled;
     while (m_recycledMailboxQueue.size() > cacheLimit) {
         recycled = m_recycledMailboxQueue.takeLast();
         deleteMailbox(recycled->mailbox, recycled->syncToken);
     }
     recycled = m_recycledMailboxQueue.takeLast();
 
     if (recycled->syncToken.HasData())
@@ skipping 581 matching lines @@
     m_gl->Clear(GL_COLOR_BUFFER_BIT);
     m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, info.parameters.target, 0, 0);
     m_gl->DeleteFramebuffers(1, &fbo);
     restoreFramebufferBindings();
     m_gl->ClearColor(m_clearColor[0], m_clearColor[1], m_clearColor[2], m_clearColor[3]);
     m_gl->ColorMask(m_colorMask[0], m_colorMask[1], m_colorMask[2], m_colorMask[3]);
 }
 
 DrawingBuffer::TextureInfo DrawingBuffer::createTextureAndAllocateMemory(const IntSize& size)
 {
-    if (!RuntimeEnabledFeatures::webGLImageChromiumEnabled())
+    if (!shouldUseChromiumImage())
         return createDefaultTextureAndAllocateMemory(size);
 
     TextureParameters parameters = chromiumImageTextureParameters();
     GLuint imageId = m_gl->CreateGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), parameters.creationInternalColorFormat, GC3D_SCANOUT_CHROMIUM);
     GLuint textureId = createColorTexture(parameters);
     if (imageId) {
         m_gl->BindTexImage2DCHROMIUM(parameters.target, imageId);
     }
 
     TextureInfo info;
@@ skipping 12 matching lines @@
     info.textureId = createColorTexture(parameters);
     allocateConditionallyImmutableTexture(parameters.target, parameters.creationInternalColorFormat,
         size.width(), size.height(), 0, parameters.colorFormat, GL_UNSIGNED_BYTE);
     info.immutable = m_storageTextureSupported;
     return info;
 }
 
 void DrawingBuffer::resizeTextureMemory(TextureInfo* info, const IntSize& size)
 {
     ASSERT(info->textureId);
-    if (!RuntimeEnabledFeatures::webGLImageChromiumEnabled()) {
+    if (!shouldUseChromiumImage()) {
         if (info->immutable) {
             DCHECK(m_storageTextureSupported);
             m_gl->DeleteTextures(1, &info->textureId);
             info->textureId = createColorTexture(info->parameters);
         }
         m_gl->BindTexture(info->parameters.target, info->textureId);
         allocateConditionallyImmutableTexture(info->parameters.target, info->parameters.creationInternalColorFormat,
             size.width(), size.height(), 0, info->parameters.colorFormat, GL_UNSIGNED_BYTE);
         info->immutable = m_storageTextureSupported;
         return;
@@ skipping 39 matching lines @@
 bool DrawingBuffer::wantDepthOrStencil()
 {
     return m_wantDepth || m_wantStencil;
 }
 
 GLenum DrawingBuffer::getMultisampledRenderbufferFormat()
 {
     DCHECK(wantExplicitResolve());
     if (m_wantAlphaChannel)
         return GL_RGBA8_OES;
-    if (RuntimeEnabledFeatures::webGLImageChromiumEnabled() && contextProvider()->getCapabilities().chromium_image_rgb_emulation)
+    if (shouldUseChromiumImage() && contextProvider()->getCapabilities().chromium_image_rgb_emulation)
         return GL_RGBA8_OES;
     if (contextProvider()->getCapabilities().disable_webgl_rgb_multisampling_usage)
         return GL_RGBA8_OES;
     return GL_RGB8_OES;
 }
 
 void DrawingBuffer::restoreTextureBindings()
 {
     // This class potentially modifies the bindings for GL_TEXTURE_2D and
     // GL_TEXTURE_RECTANGLE. Only GL_TEXTURE_2D needs to be restored since
     // the public interface for WebGL does not support GL_TEXTURE_RECTANGLE.
     m_gl->BindTexture(GL_TEXTURE_2D, m_texture2DBinding);
 }
 
+bool DrawingBuffer::shouldUseChromiumImage()
+{
+    return RuntimeEnabledFeatures::webGLImageChromiumEnabled() && m_chromiumImageUsage == AllowChromiumImage;
+}
+
 } // namespace blink