DrawingBuffer: Use gfx::GpuMemoryBuffer directly and set color space

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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/graphics/gpu/DrawingBuffer.h"
 
 #include "cc/resources/shared_bitmap.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/common/capabilities.h"
+#include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/AcceleratedStaticBitmapImage.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/WebGraphicsContext3DProviderWrapper.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebExternalBitmap.h"
@@ skipping 98 matching lines @@
       m_contextProvider(WTF::wrapUnique(
           new WebGraphicsContext3DProviderWrapper(std::move(contextProvider)))),
       m_gl(this->contextProvider()->contextGL()),
       m_extensionsUtil(std::move(extensionsUtil)),
       m_discardFramebufferSupported(discardFramebufferSupported),
       m_wantAlphaChannel(wantAlphaChannel),
       m_premultipliedAlpha(premultipliedAlpha),
       m_softwareRendering(this->contextProvider()->isSoftwareRendering()),
       m_wantDepth(wantDepth),
       m_wantStencil(wantStencil),
+      m_colorSpace(gfx::ColorSpace::CreateSRGB()),
       m_chromiumImageUsage(chromiumImageUsage) {
   // Used by browser tests to detect the use of a DrawingBuffer.
   TRACE_EVENT_INSTANT0("test_gpu", "DrawingBufferCreation",
                        TRACE_EVENT_SCOPE_GLOBAL);
 }
 
 DrawingBuffer::~DrawingBuffer() {
   DCHECK(m_destructionInProgress);
   m_layer.reset();
   m_contextProvider.reset();
@@ skipping 139 matching lines @@
     DCHECK(pixels);
     bool needPremultiply = m_wantAlphaChannel && !m_premultipliedAlpha;
     WebGLImageConversion::AlphaOp op =
         needPremultiply ? WebGLImageConversion::AlphaDoPremultiply
                         : WebGLImageConversion::AlphaDoNothing;
     readBackFramebuffer(pixels, size().width(), size().height(), ReadbackSkia,
                         op);
   }
 
   *outMailbox = cc::TextureMailbox(bitmap.get(), m_size);
+  outMailbox->set_color_space(m_colorSpace);
 
   // This holds a ref on the DrawingBuffer that will keep it alive until the
   // mailbox is released (and while the release callback is running). It also
   // owns the SharedBitmap.
   auto func = WTF::bind(&DrawingBuffer::mailboxReleasedSoftware,
                         RefPtr<DrawingBuffer>(this),
                         WTF::passed(std::move(bitmap)), m_size);
   *outReleaseCallback =
       cc::SingleReleaseCallback::Create(convertToBaseCallback(std::move(func)));
   return true;
@@ skipping 52 matching lines @@
   }
 
   // Populate the output mailbox and callback.
   {
     bool isOverlayCandidate = colorBufferForMailbox->imageId != 0;
     bool secureOutputOnly = false;
     *outMailbox = cc::TextureMailbox(
         colorBufferForMailbox->mailbox, colorBufferForMailbox->produceSyncToken,
         colorBufferForMailbox->parameters.target, gfx::Size(m_size),
         isOverlayCandidate, secureOutputOnly);
+    outMailbox->set_color_space(m_colorSpace);
 
     // This holds a ref on the DrawingBuffer that will keep it alive until the
     // mailbox is released (and while the release callback is running).
     auto func = WTF::bind(&DrawingBuffer::mailboxReleasedGpu,
                           RefPtr<DrawingBuffer>(this), colorBufferForMailbox);
     *outReleaseCallback = cc::SingleReleaseCallback::Create(
         convertToBaseCallback(std::move(func)));
   }
 
   // Point |m_frontColorBuffer| to the buffer that we are now presenting.
@@ skipping 169 matching lines @@
   if (!m_recycledColorBufferQueue.isEmpty()) {
     RefPtr<ColorBuffer> recycled = m_recycledColorBufferQueue.takeLast();
     if (recycled->receiveSyncToken.HasData())
       m_gl->WaitSyncTokenCHROMIUM(recycled->receiveSyncToken.GetData());
     DCHECK(recycled->size == m_size);
     return recycled;
   }
   return createColorBuffer(m_size);
 }
 
-DrawingBuffer::ColorBuffer::ColorBuffer(DrawingBuffer* drawingBuffer,
-                                        const ColorBufferParameters& parameters,
-                                        const IntSize& size,
-                                        GLuint textureId,
-                                        GLuint imageId)
+DrawingBuffer::ColorBuffer::ColorBuffer(
+    DrawingBuffer* drawingBuffer,
+    const ColorBufferParameters& parameters,
+    const IntSize& size,
+    GLuint textureId,
+    GLuint imageId,
+    std::unique_ptr<gfx::GpuMemoryBuffer> gpuMemoryBuffer)
     : drawingBuffer(drawingBuffer),
       parameters(parameters),
       size(size),
       textureId(textureId),
-      imageId(imageId) {
+      imageId(imageId),
+      gpuMemoryBuffer(std::move(gpuMemoryBuffer)) {
   drawingBuffer->contextGL()->GenMailboxCHROMIUM(mailbox.name);
 }
 
 DrawingBuffer::ColorBuffer::~ColorBuffer() {
   gpu::gles2::GLES2Interface* gl = drawingBuffer->m_gl;
   if (receiveSyncToken.HasData())
     gl->WaitSyncTokenCHROMIUM(receiveSyncToken.GetConstData());
   if (imageId) {
     gl->BindTexture(parameters.target, textureId);
     gl->ReleaseTexImage2DCHROMIUM(parameters.target, imageId);
     gl->DestroyImageCHROMIUM(imageId);
     switch (parameters.target) {
       case GL_TEXTURE_2D:
         // Restore the texture binding for GL_TEXTURE_2D, since the client will
         // expect the previous state.
         if (drawingBuffer->m_client)
           drawingBuffer->m_client->DrawingBufferClientRestoreTexture2DBinding();
         break;
       case GC3D_TEXTURE_RECTANGLE_ARB:
         // Rectangle textures aren't exposed to WebGL, so don't bother
         // restoring this state (there is no meaningful way to restore it).
         break;
       default:
         NOTREACHED();
         break;
     }
+    gpuMemoryBuffer.reset();
   }
   gl->DeleteTextures(1, &textureId);
 }
 
 bool DrawingBuffer::initialize(const IntSize& size, bool useMultisampling) {
   ScopedStateRestorer scopedStateRestorer(this);
 
   if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
     // Need to try to restore the context again later.
     return false;
@@ skipping 501 matching lines @@
 RefPtr<DrawingBuffer::ColorBuffer> DrawingBuffer::createColorBuffer(
     const IntSize& size) {
   DCHECK(m_stateRestorer);
   m_stateRestorer->setFramebufferBindingDirty();
   m_stateRestorer->setTextureBindingDirty();
 
   // Select the Parameters for the texture object. Allocate the backing
   // GpuMemoryBuffer and GLImage, if one is going to be used.
   ColorBufferParameters parameters;
   GLuint imageId = 0;
-  if (shouldUseChromiumImage()) {
+  std::unique_ptr<gfx::GpuMemoryBuffer> gpuMemoryBuffer;
+  gpu::GpuMemoryBufferManager* gpuMemoryBufferManager =
+      Platform::current()->getGpuMemoryBufferManager();
+  if (shouldUseChromiumImage() && gpuMemoryBufferManager) {
     parameters = gpuMemoryBufferColorBufferParameters();
-    imageId = m_gl->CreateGpuMemoryBufferImageCHROMIUM(
-        size.width(), size.height(), parameters.creationInternalColorFormat,
-        GC3D_SCANOUT_CHROMIUM);
+    gfx::BufferFormat bufferFormat = gpu::DefaultBufferFormatForImageFormat(
+        parameters.creationInternalColorFormat);
+    gpuMemoryBuffer = gpuMemoryBufferManager->CreateGpuMemoryBuffer(
+        gfx::Size(size), bufferFormat, gfx::BufferUsage::SCANOUT,
+        gpu::kNullSurfaceHandle);
+    if (gpuMemoryBuffer) {
+      if (RuntimeEnabledFeatures::colorCorrectRenderingEnabled())
+        gpuMemoryBuffer->SetColorSpaceForScanout(m_colorSpace);
+      imageId = m_gl->CreateImageCHROMIUM(
+          gpuMemoryBuffer->AsClientBuffer(), size.width(), size.height(),
+          parameters.creationInternalColorFormat);
+      if (!imageId)
+        gpuMemoryBuffer.reset();
+    }
   } else {
     parameters = textureColorBufferParameters();
   }
 
   // Allocate the texture for this object.
   GLuint textureId = 0;
   {
     m_gl->GenTextures(1, &textureId);
     m_gl->BindTexture(parameters.target, textureId);
     m_gl->TexParameteri(parameters.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ skipping 37 matching lines @@
     m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                parameters.target, textureId, 0);
     m_gl->ClearColor(0, 0, 0, 1);
     m_gl->ColorMask(false, false, false, true);
     m_gl->Clear(GL_COLOR_BUFFER_BIT);
     m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                parameters.target, 0, 0);
     m_gl->DeleteFramebuffers(1, &fbo);
   }
 
-  return adoptRef(new ColorBuffer(this, parameters, size, textureId, imageId));
+  return adoptRef(new ColorBuffer(this, parameters, size, textureId, imageId,
+                                  std::move(gpuMemoryBuffer)));
 }
 
 void DrawingBuffer::attachColorBufferToReadFramebuffer() {
   DCHECK(m_stateRestorer);
   m_stateRestorer->setFramebufferBindingDirty();
   m_stateRestorer->setTextureBindingDirty();
 
   m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
 
   GLenum target = m_backColorBuffer->parameters.target;
@@ skipping 61 matching lines @@
   if (m_pixelUnpackBufferBindingDirty)
     client->DrawingBufferClientRestorePixelUnpackBufferBinding();
 }
 
 bool DrawingBuffer::shouldUseChromiumImage() {
   return RuntimeEnabledFeatures::webGLImageChromiumEnabled() &&
          m_chromiumImageUsage == AllowChromiumImage;
 }
 
 }  // namespace blink