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 129 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)

[Ken Russell (switch to Gerrit), 2014/04/28 20:51:45]

What happens when the DrawingBuffer is un-hidden? Will the page redraw
correctly? Is there a test verifying this case?

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

When un-hidden, DrawingBuffer recreate mailbox for compositor in
prepareMailbox().

That's good concern. I'll make a layout test. It would be pixel test after
hidden and unhidden.

+{
+    ASSERT(!m_destructionInProgress);
+    bool newHiddenValue = hidden || m_destructionInProgress;
+    if (m_isHidden == newHiddenValue)
+        return;
+
+    m_isHidden = newHiddenValue;
+    if (m_isHidden)
+        freeRecycledMailboxes();

[Justin Novosad, 2014/04/28 15:21:42]

This is a good start. Eventually we should experiment with freeing even more.
Perhaps even evict the entire context and restore it when the pages becomes
visible again.

[Ken Russell (switch to Gerrit), 2014/04/28 20:51:45]

zmo@ is actively working on deciding when to evict WebGL contexts, and which
contexts to evict. Let's not collide or duplicate work in this area.

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

IMO, it's not overlapped with evicting contexts. This CL just removes temporary
mailboxs (= textures), when page is hidden. zmo@, wdyt? 

+}
+
+void DrawingBuffer::freeRecycledMailboxes()
+{
+    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)
         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 62 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->textureId;
     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 708 matching lines @@
     }
 }
 
 void DrawingBuffer::texImage2DResourceSafe(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLint unpackAlignment)
 {
     ASSERT(unpackAlignment == 1 || unpackAlignment == 2 || unpackAlignment == 4 || unpackAlignment == 8);
     m_context->texImage2D(target, level, internalformat, width, height, border, format, type, 0);
 }
 
 } // namespace WebCore