DrawingBuffer cleanup: Part 1 of many

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 390 matching lines @@
 
   m_frontColorBuffer = {mailboxInfo->mailbox, syncToken,
                         mailboxInfo->textureInfo};
   setBufferClearNeeded(true);
   return true;
 }
 
 void DrawingBuffer::gpuMailboxReleased(const gpu::Mailbox& mailbox,
                                        const gpu::SyncToken& syncToken,
                                        bool lostResource) {
-  if (m_destructionInProgress ||
+  // Creation of image backed mailboxes is very expensive, so be less
+  // aggressive about pruning them.
+  size_t cacheLimit = 1;
+  if (shouldUseChromiumImage())
+    cacheLimit = 4;
+
+  if (m_destructionInProgress || m_recycledMailboxQueue.size() >= cacheLimit ||
       m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR || lostResource ||
       m_isHidden) {
     deleteMailbox(mailbox, syncToken);
     return;
   }
 
+  RefPtr<MailboxInfo> mailboxInfo;
   for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
-    RefPtr<MailboxInfo> mailboxInfo = m_textureMailboxes[i];
-    if (mailboxInfo->mailbox == mailbox) {
-      m_recycledMailboxQueue.prepend(
-          adoptRef(new RecycledMailbox(mailbox, syncToken)));
-      return;
+    if (m_textureMailboxes[i]->mailbox == mailbox) {
+      mailboxInfo = m_textureMailboxes[i];
+      break;
     }
   }
-  ASSERT_NOT_REACHED();
+  DCHECK(mailboxInfo);
+  if (mailboxInfo->size != m_size) {
+    deleteMailbox(mailbox, syncToken);
+    return;
+  }
+
+  m_recycledMailboxQueue.prepend(
+      adoptRef(new RecycledMailbox(mailbox, syncToken)));
 }
 
 void DrawingBuffer::softwareMailboxReleased(
     std::unique_ptr<cc::SharedBitmap> bitmap,
     const IntSize& size,
     const gpu::SyncToken& syncToken,
     bool lostResource) {
   DCHECK(!syncToken.HasData());  // No sync tokens for software resources.
   if (m_destructionInProgress || lostResource || m_isHidden || size != m_size)
     return;  // Just delete the bitmap.
@@ skipping 126 matching lines @@
     parameters.internalColorFormat = format;
     parameters.colorFormat = format;
   }
   return parameters;
 }
 
 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 (shouldUseChromiumImage())
-    cacheLimit = 4;
-
-  RefPtr<RecycledMailbox> recycled;
-  while (m_recycledMailboxQueue.size() > cacheLimit) {
-    recycled = m_recycledMailboxQueue.takeLast();
-    deleteMailbox(recycled->mailbox, recycled->syncToken);
-  }
-  recycled = m_recycledMailboxQueue.takeLast();
-
+  RefPtr<RecycledMailbox> recycled = m_recycledMailboxQueue.takeLast();
   if (recycled->syncToken.HasData())
     m_gl->WaitSyncTokenCHROMIUM(recycled->syncToken.GetData());
 
   RefPtr<MailboxInfo> mailboxInfo;
   for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
     if (m_textureMailboxes[i]->mailbox == recycled->mailbox) {
       mailboxInfo = m_textureMailboxes[i];
       break;
     }
   }
-  ASSERT(mailboxInfo);
-
-  if (mailboxInfo->size != m_size) {
-    resizeTextureMemory(&mailboxInfo->textureInfo, m_size);
-    mailboxInfo->size = m_size;
-  }
-
+  DCHECK(mailboxInfo);
+  DCHECK(mailboxInfo->size == m_size);

[Ken Russell (switch to Gerrit), 2016/10/06 03:47:52]

Am I understanding correctly that this invariant is now maintained by:

 - Discarding recycled mailboxes in gpuMailboxReleased if it has a different
size
 - Throwing out all of the recycled mailboxes in DrawingBuffer::reset

? Just trying to understand the situation.

[ccameron, 2016/10/06 08:34:24]

Yes, exactly.

   return mailboxInfo.release();
 }
 
 PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::createNewMailbox(
     const TextureInfo& info) {
   RefPtr<MailboxInfo> returnMailbox = adoptRef(new MailboxInfo);
   m_gl->GenMailboxCHROMIUM(returnMailbox->mailbox.name);
   returnMailbox->textureInfo = info;
   returnMailbox->size = m_size;
   m_textureMailboxes.append(returnMailbox);
@@ skipping 185 matching lines @@
     m_gl->DeleteRenderbuffers(1, &m_multisampleRenderbuffer);
 
   if (m_depthStencilBuffer)
     m_gl->DeleteRenderbuffers(1, &m_depthStencilBuffer);
 
   if (m_colorBuffer.textureId) {
     deleteChromiumImageForTexture(&m_colorBuffer);
     m_gl->DeleteTextures(1, &m_colorBuffer.textureId);
   }
 
-  setSize(IntSize());
+  m_size = IntSize();
 
   m_colorBuffer = TextureInfo();
   m_frontColorBuffer = FrontBufferInfo();
   m_multisampleRenderbuffer = 0;
   m_depthStencilBuffer = 0;
   m_multisampleFBO = 0;
   m_fbo = 0;
 
   if (m_layer)
     GraphicsLayer::unregisterContentsLayer(m_layer->layer());
 }
 
 GLuint DrawingBuffer::createColorTexture(const TextureParameters& parameters) {
   GLuint offscreenColorTexture;
   m_gl->GenTextures(1, &offscreenColorTexture);
   m_gl->BindTexture(parameters.target, offscreenColorTexture);
   m_gl->TexParameteri(parameters.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   m_gl->TexParameteri(parameters.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   m_gl->TexParameteri(parameters.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   m_gl->TexParameteri(parameters.target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   return offscreenColorTexture;
 }
 
-bool DrawingBuffer::resizeMultisampleFramebuffer(const IntSize& size) {
-  DCHECK(wantExplicitResolve());
-  m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
-  m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_multisampleRenderbuffer);
-  m_gl->RenderbufferStorageMultisampleCHROMIUM(
-      GL_RENDERBUFFER, m_sampleCount, getMultisampledRenderbufferFormat(),
-      size.width(), size.height());
-
-  if (m_gl->GetError() == GL_OUT_OF_MEMORY)
-    return false;
-
-  m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-                                GL_RENDERBUFFER, m_multisampleRenderbuffer);
-
-  return true;
-}
-
-void DrawingBuffer::resizeDepthStencil(const IntSize& size) {
-  m_gl->BindFramebuffer(GL_FRAMEBUFFER,
-                        m_multisampleFBO ? m_multisampleFBO : m_fbo);
-  if (!m_depthStencilBuffer)
-    m_gl->GenRenderbuffers(1, &m_depthStencilBuffer);
-  m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
-  if (m_antiAliasingMode == MSAAImplicitResolve)
-    m_gl->RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, m_sampleCount,
-                                            GL_DEPTH24_STENCIL8_OES,
-                                            size.width(), size.height());
-  else if (m_antiAliasingMode == MSAAExplicitResolve)
-    m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount,
-                                                 GL_DEPTH24_STENCIL8_OES,
-                                                 size.width(), size.height());
-  else
-    m_gl->RenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES,
-                              size.width(), size.height());
-  // For ES 2.0 contexts DEPTH_STENCIL is not available natively, so we emulate
-  // it at the command buffer level for WebGL contexts.
-  m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
-                                GL_RENDERBUFFER, m_depthStencilBuffer);
-  m_gl->BindRenderbuffer(GL_RENDERBUFFER, 0);
-}
-
 bool DrawingBuffer::resizeDefaultFramebuffer(const IntSize& size) {
   // Resize or create m_colorBuffer.
   if (m_colorBuffer.textureId) {
-    resizeTextureMemory(&m_colorBuffer, size);
-  } else {
-    m_colorBuffer = createTextureAndAllocateMemory(size);
+    deleteChromiumImageForTexture(&m_colorBuffer);
+    m_gl->DeleteTextures(1, &m_colorBuffer.textureId);
   }
+  m_colorBuffer = createTextureAndAllocateMemory(size);
 
   attachColorBufferToReadFramebuffer();
 
   if (wantExplicitResolve()) {
-    if (!resizeMultisampleFramebuffer(size))
+    m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
+    m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_multisampleRenderbuffer);
+    m_gl->RenderbufferStorageMultisampleCHROMIUM(
+        GL_RENDERBUFFER, m_sampleCount, getMultisampledRenderbufferFormat(),
+        size.width(), size.height());
+
+    if (m_gl->GetError() == GL_OUT_OF_MEMORY)
       return false;
+
+    m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                                  GL_RENDERBUFFER, m_multisampleRenderbuffer);
   }
 
-  if (wantDepthOrStencil())
-    resizeDepthStencil(size);
+  if (wantDepthOrStencil()) {
+    m_gl->BindFramebuffer(GL_FRAMEBUFFER,
+                          m_multisampleFBO ? m_multisampleFBO : m_fbo);
+    if (!m_depthStencilBuffer)
+      m_gl->GenRenderbuffers(1, &m_depthStencilBuffer);
+    m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
+    if (m_antiAliasingMode == MSAAImplicitResolve) {
+      m_gl->RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, m_sampleCount,
+                                              GL_DEPTH24_STENCIL8_OES,
+                                              size.width(), size.height());
+    } else if (m_antiAliasingMode == MSAAExplicitResolve) {
+      m_gl->RenderbufferStorageMultisampleCHROMIUM(
+          GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(),
+          size.height());
+    } else {
+      m_gl->RenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES,
+                                size.width(), size.height());
+    }
+    // For ES 2.0 contexts DEPTH_STENCIL is not available natively, so we
+    // emulate
+    // it at the command buffer level for WebGL contexts.
+    m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+                                  GL_RENDERBUFFER, m_depthStencilBuffer);
+    m_gl->BindRenderbuffer(GL_RENDERBUFFER, 0);
+  }
 
   if (wantExplicitResolve()) {
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
     if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
       return false;
   }
 
   m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
   return m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) ==
          GL_FRAMEBUFFER_COMPLETE;
 }
 
 void DrawingBuffer::clearFramebuffers(GLbitfield clearMask) {
   // We will clear the multisample FBO, but we also need to clear the
   // non-multisampled buffer.
   if (m_multisampleFBO) {
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     m_gl->Clear(GL_COLOR_BUFFER_BIT);
   }
 
   m_gl->BindFramebuffer(GL_FRAMEBUFFER,
                         m_multisampleFBO ? m_multisampleFBO : m_fbo);
   m_gl->Clear(clearMask);
 }
 
-void DrawingBuffer::setSize(const IntSize& size) {
-  if (m_size == size)
-    return;
-
-  m_size = size;
-}
-
 IntSize DrawingBuffer::adjustSize(const IntSize& desiredSize,
                                   const IntSize& curSize,
                                   int maxTextureSize) {
   IntSize adjustedSize = desiredSize;
 
   // Clamp if the desired size is greater than the maximum texture size for the
   // device.
   if (adjustedSize.height() > maxTextureSize)
     adjustedSize.setHeight(maxTextureSize);
 
@@ skipping 11 matching lines @@
 
   if (adjustedSize != m_size) {
     do {
       if (!resizeDefaultFramebuffer(adjustedSize)) {
         adjustedSize.scale(s_resourceAdjustedRatio);
         continue;
       }
       break;
     } while (!adjustedSize.isEmpty());
 
-    setSize(adjustedSize);
+    m_size = adjustedSize;
 
     if (adjustedSize.isEmpty())
       return false;
   }
 
   m_gl->Disable(GL_SCISSOR_TEST);
   m_gl->ClearColor(0, 0, 0,
                    defaultBufferRequiresAlphaChannelToBePreserved() ? 1 : 0);
   m_gl->ColorMask(true, true, true, true);
 
   GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
   if (!!m_depthStencilBuffer) {
     m_gl->ClearDepthf(1.0f);
     clearMask |= GL_DEPTH_BUFFER_BIT;
     m_gl->DepthMask(true);
   }
   if (!!m_depthStencilBuffer) {
     m_gl->ClearStencil(0);
     clearMask |= GL_STENCIL_BUFFER_BIT;
     m_gl->StencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
   }
 
   clearFramebuffers(clearMask);
+  freeRecycledMailboxes();
   return true;
 }
 
 void DrawingBuffer::commit() {
   if (wantExplicitResolve() && !m_contentsChangeCommitted) {
     m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER_ANGLE, m_multisampleFBO);
     m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER_ANGLE, m_fbo);
 
     if (m_scissorEnabled)
       m_gl->Disable(GL_SCISSOR_TEST);
@@ skipping 254 matching lines @@
 
 DrawingBuffer::TextureInfo DrawingBuffer::createDefaultTextureAndAllocateMemory(
     const IntSize& size) {
   DrawingBuffer::TextureInfo info;
   TextureParameters parameters = defaultTextureParameters();
   info.parameters = parameters;
   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 (!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;
-  }
-
-  DCHECK(!info->immutable);
-  deleteChromiumImageForTexture(info);
-  info->imageId = m_gl->CreateGpuMemoryBufferImageCHROMIUM(
-      size.width(), size.height(), info->parameters.creationInternalColorFormat,
-      GC3D_SCANOUT_CHROMIUM);
-  if (info->imageId) {
-    m_gl->BindTexture(info->parameters.target, info->textureId);
-    m_gl->BindTexImage2DCHROMIUM(info->parameters.target, info->imageId);
-    clearChromiumImageAlpha(*info);
-  } else {
-    // At this point, the texture still exists, but has no allocated
-    // storage. This is intentional, and mimics the behavior of a texImage2D
-    // failure.
-  }
-}
-
 void DrawingBuffer::attachColorBufferToReadFramebuffer() {
   m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
 
   GLenum target = m_colorBuffer.parameters.target;
   GLenum id = m_colorBuffer.textureId;
 
   m_gl->BindTexture(target, id);
 
   if (m_antiAliasingMode == MSAAImplicitResolve)
     m_gl->FramebufferTexture2DMultisampleEXT(
@@ skipping 34 matching lines @@
   // 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