WebGL: Free temporary GPU resources held by inactive or hidden WebGL.

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 130 matching lines @@
     , m_contentsChangeCommitted(false)
     , m_layerComposited(false)
     , m_multisampleMode(None)
     , m_internalColorFormat(0)
     , m_colorFormat(0)
     , m_internalRenderbufferFormat(0)
     , m_maxTextureSize(0)
     , m_sampleCount(0)
     , m_packAlignment(4)
     , m_destructionInProgress(false)
+    , m_isHidden(false)
     , m_contextEvictionManager(contextEvictionManager)
 {
     // Used by browser tests to detect the use of a DrawingBuffer.
     TRACE_EVENT_INSTANT0("test_gpu", "DrawingBufferCreation");
 #ifndef NDEBUG
     drawingBufferCounter.increment();
 #endif
 }
 
 DrawingBuffer::~DrawingBuffer()
@@ skipping 17 matching lines @@
 bool DrawingBuffer::layerComposited() const
 {
     return m_layerComposited;
 }
 
 void DrawingBuffer::markLayerComposited()
 {
     m_layerComposited = true;
 }
 
+
+void DrawingBuffer::setIsHidden(bool hidden)
+{
+    ASSERT(!m_destructionInProgress);
+    bool newHiddenValue = hidden || m_destructionInProgress;
+    if (m_isHidden == newHiddenValue)
+        return;
+
+    m_isHidden = newHiddenValue;
+    if (m_isHidden)
+        freeRecycledMailboxes();

[danakj, 2014/07/09 15:27:28]

Have you considered sending the renderer compositor an empty frame to let it
release its resource back to you if the browser evicts the frame also?

[dshwang, 2014/07/09 16:04:29]

I've not considered yet.
Currently, WebGL can release resource after resource_provider calls release
callback of external resource.
Do you mean that it might be better to create some pulling mechanism to make
WebGL take resources from compositor synchronously?
Could you explain more what you're worry about?

[danakj, 2014/07/09 16:08:48]

I mean if WebGL goes invisible the renderer compositor still has the last
mailbox given to it. I was thinking if you give cc an empty mailbox then it can
release the ref held on it by the renderer compositor.

BUT, cc stops doing commits and stuff while not visible, so actually that won't
work. cc would have to initiate the release when it goes invisible in
LTHI::SetVisible
https://code.google.com/p/chromium/codesearch#chromium/src/cc/trees/layer_tre...
but I don't think it does for any external resources right now. So that's def
outside the scope of this CL. :)

[Ken Russell (switch to Gerrit), 2014/07/09 17:27:17]

If the compositor releases its reference to the last produced mailbox and then
the tab is brought to the foreground without the app redrawing the WebGL canvas,
what will happen? Will the compositor still be able to draw the most recently
produced output from the canvas? This is also needed for printing.

+}
+
+void DrawingBuffer::freeRecycledMailboxes()
+{
+    if (m_recycledMailboxQueue.isEmpty())
+        return;
+    m_context->makeContextCurrent();
+    while (!m_recycledMailboxQueue.isEmpty())
+        deleteMailbox(m_recycledMailboxQueue.takeLast());
+}
+
 blink::WebGraphicsContext3D* DrawingBuffer::context()
 {
     return m_context.get();
 }
 
 bool DrawingBuffer::prepareMailbox(blink::WebExternalTextureMailbox* outMailbox, blink::WebExternalBitmap* bitmap)
 {
-    if (!m_contentsChanged)
+    if (!m_contentsChanged || m_isHidden)

[danakj, 2014/07/09 15:27:28]

Does this ever happen? The compositor never produces frames while hidden.

[dshwang, 2014/07/09 16:04:29]

That's good point. I think so. Let me check.

         return false;
 
     if (m_destructionInProgress) {
         // It can be hit in the following sequence.
         // 1. WebGL draws something.
         // 2. The compositor begins the frame.
         // 3. Javascript makes a context lost using WEBGL_lose_context extension.
         // 4. Here.
         return false;
     }
@@ skipping 65 matching lines @@
     // set m_parentDrawingBuffer to make sure 'this' stays alive as long as it has live mailboxes
     ASSERT(!frontColorBufferMailbox->m_parentDrawingBuffer);
     frontColorBufferMailbox->m_parentDrawingBuffer = this;
     *outMailbox = frontColorBufferMailbox->mailbox;
     m_frontColorBuffer = frontColorBufferMailbox->textureInfo;
     return true;
 }
 
 void DrawingBuffer::mailboxReleased(const blink::WebExternalTextureMailbox& mailbox)
 {
-    if (m_destructionInProgress) {
-        mailboxReleasedWhileDestructionInProgress(mailbox);
+    if (m_destructionInProgress || m_isHidden) {
+        mailboxReleasedWithoutRecycling(mailbox);
         return;
     }
 
     for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
         RefPtr<MailboxInfo> mailboxInfo = m_textureMailboxes[i];
         if (nameEquals(mailboxInfo->mailbox, mailbox)) {
             mailboxInfo->mailbox.syncPoint = mailbox.syncPoint;
             ASSERT(mailboxInfo->m_parentDrawingBuffer.get() == this);
             mailboxInfo->m_parentDrawingBuffer.clear();
             m_recycledMailboxQueue.prepend(mailboxInfo->mailbox);
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
 
-void DrawingBuffer::mailboxReleasedWhileDestructionInProgress(const blink::WebExternalTextureMailbox& mailbox)
+void DrawingBuffer::mailboxReleasedWithoutRecycling(const blink::WebExternalTextureMailbox& mailbox)
 {
     ASSERT(m_textureMailboxes.size());
     m_context->makeContextCurrent();
     // Ensure not to call the destructor until deleteMailbox() is completed.
     RefPtr<DrawingBuffer> self = this;
     deleteMailbox(mailbox);
 }
 
 PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::recycledMailbox()
 {
@@ skipping 753 matching lines @@
 void DrawingBuffer::deleteChromiumImageForTexture(TextureInfo* info)
 {
     if (info->imageId) {
         m_context->releaseTexImage2DCHROMIUM(GL_TEXTURE_2D, info->imageId);
         m_context->destroyImageCHROMIUM(info->imageId);
         info->imageId = 0;
     }
 }
 
 } // namespace WebCore