DrawingBuffer cleanup: Merge structures

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 164 matching lines @@
       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);
-  ASSERT(m_textureMailboxes.isEmpty());
+  DCHECK(m_destructionInProgress);
   m_layer.reset();
   m_contextProvider.reset();
 }
 
 void DrawingBuffer::markContentsChanged() {
   m_contentsChanged = true;
   m_contentsChangeCommitted = false;
 }
 
 bool DrawingBuffer::bufferClearNeeded() const {
@@ skipping 13 matching lines @@
 }
 
 WebGraphicsContext3DProvider* DrawingBuffer::contextProvider() {
   return m_contextProvider.get();
 }
 
 void DrawingBuffer::setIsHidden(bool hidden) {
   if (m_isHidden == hidden)
     return;
   m_isHidden = hidden;
-  if (m_isHidden)
-    freeRecycledMailboxes();
+  if (m_isHidden) {
+    m_recycledMailboxQueue.clear();
+    m_frontColorBuffer = nullptr;

[ccameron, 2016/10/06 09:24:53]

m_frontColorBuffer remained populated, but its backing texture was also
referenced in the recycle queue, and was deleted. Because we're using RefPtrs,
we need to remove both references if we want the GL resources to actually be
deleted (which some tests do).

[erikchen, 2016/10/06 23:32:51]

This induces a behavior change, specifically with the sequence:
  e.g. setIsHidden(true); setIsHidden(false); copyToPlatformTexture() 
It's possible that this new sequence is [more] correct, but it's also possible
that this new sequence breaks expected functionality. Could you investigate
this?

[ccameron, 2016/10/07 00:46:51]

Previously, this sequence would result in solid black being read back (since the
underlying texture is gone). With this patch, it would fall back to using the
backbuffer, which may or may not be solid black (if some content has been drawn
but not sent to the compositor, it would have that content).

I'd rather keep this behavior than change to not discarding the frontbuffer.

+  }
 }
 
 void DrawingBuffer::setFilterQuality(SkFilterQuality filterQuality) {
   if (m_filterQuality != filterQuality) {
     m_filterQuality = filterQuality;
     if (m_layer)
       m_layer->setNearestNeighbor(filterQuality == kNone_SkFilterQuality);
   }
 }
 
 bool DrawingBuffer::requiresAlphaChannelToBePreserved() {
   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 ||
       (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);
-  }
-}
-
 std::unique_ptr<cc::SharedBitmap> DrawingBuffer::createOrRecycleBitmap() {
   auto it = std::remove_if(
       m_recycledBitmaps.begin(), m_recycledBitmaps.end(),
       [this](const RecycledBitmap& bitmap) { return bitmap.size != m_size; });
   m_recycledBitmaps.shrink(it - m_recycledBitmaps.begin());
 
   if (!m_recycledBitmaps.isEmpty()) {
     RecycledBitmap recycled = std::move(m_recycledBitmaps.last());
     m_recycledBitmaps.removeLast();
     DCHECK(recycled.size == m_size);
@@ skipping 31 matching lines @@
   // software frames, until we get a new context, since the compositor will
   // be trying to get a new context and may change modes.
   if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR)
     return false;
 
   TRACE_EVENT0("blink,rail", "DrawingBuffer::prepareMailbox");
 
   if (m_newMailboxCallback)
     (*m_newMailboxCallback)();
 
-  // Resolve the multisampled buffer into m_colorBuffer texture.
+  // Resolve the multisampled buffer into m_backColorBuffer texture.
   if (m_antiAliasingMode != None)
     commit();
 
   if (m_softwareRendering && !forceGpuResult) {
     std::unique_ptr<cc::SharedBitmap> bitmap = createOrRecycleBitmap();
     if (!bitmap)
       return false;
     unsigned char* pixels = bitmap->pixels();
     DCHECK(pixels);
 
@@ skipping 20 matching lines @@
   if (m_webGLVersion > WebGL1) {
     m_gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
   }
 
   // We must restore the texture binding since creating new textures,
   // consuming and producing mailboxes changes it.
   ScopedTextureUnit0BindingRestorer restorer(m_gl, m_activeTextureUnit,
                                              m_texture2DBinding);
 
   // First try to recycle an old buffer.
-  RefPtr<MailboxInfo> mailboxInfo = takeRecycledMailbox();
+  RefPtr<ColorBuffer> colorBufferForMailbox = takeRecycledMailbox();
 
   // No buffer available to recycle, create a new one.
-  if (!mailboxInfo)
-    mailboxInfo = createNewMailbox(createTextureAndAllocateMemory(m_size));
+  if (!colorBufferForMailbox)
+    colorBufferForMailbox = createTextureAndAllocateMemory(m_size);
 
   if (m_preserveDrawingBuffer == Discard) {
-    std::swap(mailboxInfo->textureInfo, m_colorBuffer);
+    std::swap(colorBufferForMailbox, m_backColorBuffer);
     attachColorBufferToReadFramebuffer();
 
     if (m_discardFramebufferSupported) {
       // Explicitly discard the framebuffer to save GPU memory bandwidth for
       // tile-based GPU arch.
       const GLenum attachments[3] = {GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT,
                                      GL_STENCIL_ATTACHMENT};
       m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
       m_gl->DiscardFramebufferEXT(GL_FRAMEBUFFER, 3, attachments);
     }
   } else {
     m_gl->CopySubTextureCHROMIUM(
-        m_colorBuffer.textureId, mailboxInfo->textureInfo.textureId, 0, 0, 0, 0,
-        m_size.width(), m_size.height(), GL_FALSE, GL_FALSE, GL_FALSE);
+        m_backColorBuffer->textureId, colorBufferForMailbox->textureId, 0, 0, 0,
+        0, m_size.width(), m_size.height(), GL_FALSE, GL_FALSE, GL_FALSE);
   }
 
   restoreFramebufferBindings();
   restorePixelUnpackBufferBindings();
   m_contentsChanged = false;
 
-  m_gl->ProduceTextureDirectCHROMIUM(mailboxInfo->textureInfo.textureId,
-                                     mailboxInfo->textureInfo.parameters.target,
-                                     mailboxInfo->mailbox.name);
+  m_gl->ProduceTextureDirectCHROMIUM(colorBufferForMailbox->textureId,
+                                     colorBufferForMailbox->parameters.target,
+                                     colorBufferForMailbox->mailbox.name);
   const GLuint64 fenceSync = m_gl->InsertFenceSyncCHROMIUM();
 #if OS(MACOSX)
   m_gl->DescheduleUntilFinishedCHROMIUM();
 #endif
   m_gl->Flush();
   gpu::SyncToken syncToken;
   m_gl->GenSyncTokenCHROMIUM(fenceSync, syncToken.GetData());
 
-  bool isOverlayCandidate = mailboxInfo->textureInfo.imageId != 0;
+  bool isOverlayCandidate = colorBufferForMailbox->imageId != 0;
   bool secureOutputOnly = false;
-  *outMailbox = cc::TextureMailbox(mailboxInfo->mailbox, syncToken,
-                                   mailboxInfo->textureInfo.parameters.target,
+  *outMailbox = cc::TextureMailbox(colorBufferForMailbox->mailbox, syncToken,
+                                   colorBufferForMailbox->parameters.target,
                                    gfx::Size(m_size.width(), m_size.height()),
                                    isOverlayCandidate, secureOutputOnly);
 
   // 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::gpuMailboxReleased,
-                        RefPtr<DrawingBuffer>(this), mailboxInfo->mailbox);
+                        RefPtr<DrawingBuffer>(this), colorBufferForMailbox);
   *outReleaseCallback =
       cc::SingleReleaseCallback::Create(convertToBaseCallback(std::move(func)));
 
-  m_frontColorBuffer = {mailboxInfo->mailbox, syncToken,
-                        mailboxInfo->textureInfo};
+  // Point |m_frontColorBuffer| to the buffer that we are presenting, and
+  // update its sync token.
+  colorBufferForMailbox->produceSyncToken = syncToken;
+  m_frontColorBuffer = colorBufferForMailbox;
   setBufferClearNeeded(true);
   return true;
 }
 
-void DrawingBuffer::gpuMailboxReleased(const gpu::Mailbox& mailbox,
+void DrawingBuffer::gpuMailboxReleased(RefPtr<ColorBuffer> colorBuffer,
                                        const gpu::SyncToken& syncToken,
                                        bool lostResource) {
-  if (m_destructionInProgress ||
+  // Update the SyncToken to ensure that we will wait for it even if we
+  // immediately destroy this buffer.
+  colorBuffer->receiveSyncToken = syncToken;
+
+  if (m_destructionInProgress || colorBuffer->size != m_size ||
       m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR || lostResource ||
       m_isHidden) {
-    deleteMailbox(mailbox, syncToken);
     return;
   }
 
   // Creation of image backed mailboxes is very expensive, so be less
   // aggressive about pruning them. Pruning is done in FIFO order.
   size_t cacheLimit = 1;
   if (shouldUseChromiumImage())
     cacheLimit = 4;
-  while (m_recycledMailboxQueue.size() >= cacheLimit) {
-    RefPtr<RecycledMailbox> recycled = m_recycledMailboxQueue.takeLast();
-    deleteMailbox(recycled->mailbox, recycled->syncToken);
-  }
+  while (m_recycledMailboxQueue.size() >= cacheLimit)
+    m_recycledMailboxQueue.takeLast();
 
-  RefPtr<MailboxInfo> mailboxInfo;

[ccameron, 2016/10/06 09:24:53]

This block is looking up the MailboxInfo from its mailbox handle. Now these just
point to the same structure.

-  for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
-    if (m_textureMailboxes[i]->mailbox == mailbox) {
-      mailboxInfo = m_textureMailboxes[i];
-      break;
-    }
-  }
-  DCHECK(mailboxInfo);
-  if (mailboxInfo->size != m_size) {
-    deleteMailbox(mailbox, syncToken);
-    return;
-  }
-
-  m_recycledMailboxQueue.prepend(
-      adoptRef(new RecycledMailbox(mailbox, syncToken)));
+  m_recycledMailboxQueue.prepend(colorBuffer);
 }
 
 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 122 matching lines @@
   } else {
     GLenum format =
         defaultBufferRequiresAlphaChannelToBePreserved() ? GL_RGBA : GL_RGB;
     parameters.creationInternalColorFormat = format;
     parameters.internalColorFormat = format;
     parameters.colorFormat = format;
   }
   return parameters;
 }
 
-PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::takeRecycledMailbox() {
+PassRefPtr<DrawingBuffer::ColorBuffer> DrawingBuffer::takeRecycledMailbox() {
   if (m_recycledMailboxQueue.isEmpty())
     return nullptr;
 
-  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;
-    }
-  }
-  DCHECK(mailboxInfo);
-  DCHECK(mailboxInfo->size == m_size);

[erikchen, 2016/10/06 23:32:51]

why get rid of this DCHECK? seems like a good sanity check.

[ccameron, 2016/10/07 00:46:51]

Yes, this is needed! Was a bit too aggressive with the cutting.

-  return mailboxInfo.release();
+  RefPtr<ColorBuffer> recycled = m_recycledMailboxQueue.takeLast();
+  if (recycled->receiveSyncToken.HasData())
+    m_gl->WaitSyncTokenCHROMIUM(recycled->receiveSyncToken.GetData());
+  return recycled;
 }
 
-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);
-  return returnMailbox.release();
+DrawingBuffer::ColorBuffer::ColorBuffer(DrawingBuffer* drawingBuffer,
+                                        const TextureParameters& parameters,
+                                        const IntSize& size)
+    : drawingBuffer(drawingBuffer), parameters(parameters), size(size) {
+  drawingBuffer->contextGL()->GenMailboxCHROMIUM(mailbox.name);
 }
 
-void DrawingBuffer::deleteMailbox(const gpu::Mailbox& mailbox,
-                                  const gpu::SyncToken& syncToken) {
-  if (syncToken.HasData())
-    m_gl->WaitSyncTokenCHROMIUM(syncToken.GetConstData());
-  for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
-    if (m_textureMailboxes[i]->mailbox == mailbox) {
-      deleteChromiumImageForTexture(&m_textureMailboxes[i]->textureInfo);
-      m_gl->DeleteTextures(1, &m_textureMailboxes[i]->textureInfo.textureId);
-      m_textureMailboxes.remove(i);
-      return;
-    }
+DrawingBuffer::ColorBuffer::~ColorBuffer() {
+  gpu::gles2::GLES2Interface* gl = drawingBuffer->contextGL();
+  if (receiveSyncToken.HasData())
+    gl->WaitSyncTokenCHROMIUM(receiveSyncToken.GetConstData());
+  if (imageId) {
+    gl->BindTexture(parameters.target, textureId);
+    gl->ReleaseTexImage2DCHROMIUM(parameters.target, imageId);
+    gl->DestroyImageCHROMIUM(imageId);
   }
-  ASSERT_NOT_REACHED();
+  gl->DeleteTextures(1, &textureId);
 }
 
 bool DrawingBuffer::initialize(const IntSize& size, bool useMultisampling) {
   if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
     // Need to try to restore the context again later.
     return false;
   }
 
   m_gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &m_maxTextureSize);
 
@@ skipping 61 matching lines @@
     m_gl->Flush();
   }
 
   // Assume that the destination target is GL_TEXTURE_2D.
   if (!Extensions3DUtil::canUseCopyTextureCHROMIUM(
           GL_TEXTURE_2D, internalFormat, destType, level))
     return false;
 
   // Contexts may be in a different share group. We must transfer the texture
   // through a mailbox first.
-  GLint textureId = 0;
   GLenum target = 0;
   gpu::Mailbox mailbox;
   gpu::SyncToken produceSyncToken;
-  if (sourceBuffer == FrontBuffer && m_frontColorBuffer.texInfo.textureId) {
-    textureId = m_frontColorBuffer.texInfo.textureId;
-    target = m_frontColorBuffer.texInfo.parameters.target;
-    mailbox = m_frontColorBuffer.mailbox;
-    produceSyncToken = m_frontColorBuffer.produceSyncToken;
+  if (sourceBuffer == FrontBuffer && m_frontColorBuffer) {
+    target = m_frontColorBuffer->parameters.target;
+    mailbox = m_frontColorBuffer->mailbox;
+    produceSyncToken = m_frontColorBuffer->produceSyncToken;
   } else {
-    textureId = m_colorBuffer.textureId;
-    target = m_colorBuffer.parameters.target;
+    target = m_backColorBuffer->parameters.target;
     m_gl->GenMailboxCHROMIUM(mailbox.name);
-    m_gl->ProduceTextureDirectCHROMIUM(textureId, target, mailbox.name);
+    m_gl->ProduceTextureDirectCHROMIUM(m_backColorBuffer->textureId, target,
+                                       mailbox.name);
     const GLuint64 fenceSync = m_gl->InsertFenceSyncCHROMIUM();
     m_gl->Flush();
     m_gl->GenSyncTokenCHROMIUM(fenceSync, produceSyncToken.GetData());
   }
 
   DCHECK(produceSyncToken.HasData());
   gl->WaitSyncTokenCHROMIUM(produceSyncToken.GetConstData());
   GLuint sourceTexture =
       gl->CreateAndConsumeTextureCHROMIUM(target, mailbox.name);
 
@@ skipping 45 matching lines @@
     m_layer->clearTexture();
 
   m_gl->Flush();
 }
 
 void DrawingBuffer::beginDestruction() {
   ASSERT(!m_destructionInProgress);
   m_destructionInProgress = true;
 
   clearPlatformLayer();
-  freeRecycledMailboxes();
+  m_recycledMailboxQueue.clear();
 
   if (m_multisampleFBO)
     m_gl->DeleteFramebuffers(1, &m_multisampleFBO);
 
   if (m_fbo)
     m_gl->DeleteFramebuffers(1, &m_fbo);
 
   if (m_multisampleRenderbuffer)
     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);
-  }
-
   m_size = IntSize();
 
-  m_colorBuffer = TextureInfo();
-  m_frontColorBuffer = FrontBufferInfo();
+  m_backColorBuffer = nullptr;
+  m_frontColorBuffer = nullptr;
   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::resizeDefaultFramebuffer(const IntSize& size) {
-  // Resize or create m_colorBuffer.
-  if (m_colorBuffer.textureId) {
-    deleteChromiumImageForTexture(&m_colorBuffer);
-    m_gl->DeleteTextures(1, &m_colorBuffer.textureId);
-  }
-  m_colorBuffer = createTextureAndAllocateMemory(size);
+  // Recreate m_backColorBuffer.
+  m_backColorBuffer = createTextureAndAllocateMemory(size);
 
   attachColorBufferToReadFramebuffer();
 
   if (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());
 
@@ skipping 102 matching lines @@
     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();
+  m_recycledMailboxQueue.clear();
+  m_recycledBitmaps.clear();
   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 89 matching lines @@
   dataSize *= width;
   dataSize *= height;
   if (!dataSize.IsValid())
     return false;
 
   WTF::ArrayBufferContents pixels(width * height, 4,
                                   WTF::ArrayBufferContents::NotShared,
                                   WTF::ArrayBufferContents::DontInitialize);
 
   GLuint fbo = 0;
-  if (sourceBuffer == FrontBuffer && m_frontColorBuffer.texInfo.textureId) {
+  if (sourceBuffer == FrontBuffer && m_frontColorBuffer) {
     m_gl->GenFramebuffers(1, &fbo);
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, fbo);
     m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-                               m_frontColorBuffer.texInfo.parameters.target,
-                               m_frontColorBuffer.texInfo.textureId, 0);
+                               m_frontColorBuffer->parameters.target,
+                               m_frontColorBuffer->textureId, 0);
   } else {
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, framebuffer());
   }
 
   readBackFramebuffer(static_cast<unsigned char*>(pixels.data()), width, height,
                       ReadbackRGBA, WebGLImageConversion::AlphaDoNothing);
   flipVertically(static_cast<uint8_t*>(pixels.data()), width, height);
 
   if (fbo) {
     m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-                               m_frontColorBuffer.texInfo.parameters.target, 0,
-                               0);
+                               m_frontColorBuffer->parameters.target, 0, 0);
     m_gl->DeleteFramebuffers(1, &fbo);
   }
 
   restoreFramebufferBindings();
 
   pixels.transfer(contents);
   return true;
 }
 
 void DrawingBuffer::readBackFramebuffer(unsigned char* pixels,
@@ skipping 63 matching lines @@
       NOTREACHED();
     }
     m_gl->TexStorage2DEXT(GL_TEXTURE_2D, 1, internalStorageFormat, width,
                           height);
     return;
   }
   m_gl->TexImage2D(target, 0, internalformat, width, height, border, format,
                    type, 0);
 }
 
-void DrawingBuffer::deleteChromiumImageForTexture(TextureInfo* info) {
-  if (info->imageId) {
-    m_gl->BindTexture(info->parameters.target, info->textureId);
-    m_gl->ReleaseTexImage2DCHROMIUM(info->parameters.target, info->imageId);
-    m_gl->DestroyImageCHROMIUM(info->imageId);
-    info->imageId = 0;
-  }
-}
-
-void DrawingBuffer::clearChromiumImageAlpha(const TextureInfo& info) {
+void DrawingBuffer::clearChromiumImageAlpha(const ColorBuffer& info) {
   if (m_wantAlphaChannel)
     return;
   if (!contextProvider()->getCapabilities().chromium_image_rgb_emulation)
     return;
 
   GLuint fbo = 0;
   m_gl->GenFramebuffers(1, &fbo);
   m_gl->BindFramebuffer(GL_FRAMEBUFFER, fbo);
   m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                              info.parameters.target, info.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,
                              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) {
+RefPtr<DrawingBuffer::ColorBuffer>
+DrawingBuffer::createTextureAndAllocateMemory(const IntSize& size) {
   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;
-  info.textureId = textureId;
-  info.imageId = imageId;
-  info.parameters = parameters;
-  clearChromiumImageAlpha(info);
+  RefPtr<ColorBuffer> info(adoptRef(new ColorBuffer(this, parameters, size)));
+  info->textureId = textureId;
+  info->imageId = imageId;
+  clearChromiumImageAlpha(*info);
   return info;
 }
 
-DrawingBuffer::TextureInfo DrawingBuffer::createDefaultTextureAndAllocateMemory(
-    const IntSize& size) {
-  DrawingBuffer::TextureInfo info;
+RefPtr<DrawingBuffer::ColorBuffer>
+DrawingBuffer::createDefaultTextureAndAllocateMemory(const IntSize& size) {
   TextureParameters parameters = defaultTextureParameters();
-  info.parameters = parameters;
-  info.textureId = createColorTexture(parameters);
+  RefPtr<ColorBuffer> info(adoptRef(new ColorBuffer(this, parameters, size)));
+  info->textureId = createColorTexture(parameters);
   allocateConditionallyImmutableTexture(
       parameters.target, parameters.creationInternalColorFormat, size.width(),
       size.height(), 0, parameters.colorFormat, GL_UNSIGNED_BYTE);
   return info;
 }
 
 void DrawingBuffer::attachColorBufferToReadFramebuffer() {
   m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
 
-  GLenum target = m_colorBuffer.parameters.target;
-  GLenum id = m_colorBuffer.textureId;
+  GLenum target = m_backColorBuffer->parameters.target;
+  GLenum id = m_backColorBuffer->textureId;
 
   m_gl->BindTexture(target, id);
 
   if (m_antiAliasingMode == MSAAImplicitResolve)
     m_gl->FramebufferTexture2DMultisampleEXT(
         GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, id, 0, m_sampleCount);
   else
     m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, id,
                                0);
 
@@ skipping 29 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