Merge 121076 - [chromium] LayerRendererChromium is not getting visibility messages in single thread…

Source/WebCore/platform/graphics/chromium/LayerRendererChromium.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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 
 #include "config.h"
 
 #if USE(ACCELERATED_COMPOSITING)
 #include "LayerRendererChromium.h"
 
 #include "Extensions3D.h"
-#include "Extensions3DChromium.h"
 #include "FloatQuad.h"
 #include "GeometryBinding.h"
 #include "GrTexture.h"
 #include "GraphicsContext3D.h"
 #include "ManagedTexture.h"
 #include "NativeImageSkia.h"
 #include "NotImplemented.h"
 #include "PlatformColor.h"
 #include "PlatformContextSkia.h"
 #include "SharedGraphicsContext3D.h"
@@ skipping 166 matching lines @@
 
 private:
     explicit LayerRendererGpuMemoryAllocationChangedCallbackAdapter(LayerRendererChromium* layerRenderer)
         : m_layerRenderer(layerRenderer), m_bindToImplThread(!CCProxy::hasImplThread())
     {
     }
 
     void onGpuMemoryAllocationChangedOnImpl(Extensions3DChromium::GpuMemoryAllocationCHROMIUM allocation)
     {
         ASSERT(CCProxy::isImplThread());
-        if (!allocation.suggestHaveBackbuffer)
-            m_layerRenderer->discardFramebuffer();
-        else
-            m_layerRenderer->ensureFramebuffer();
-        m_layerRenderer->m_client->setContentsMemoryAllocationLimitBytes(allocation.gpuResourceSizeInBytes);
+        m_layerRenderer->setGpuMemoryAllocation(allocation);
     }
 
     LayerRendererChromium* m_layerRenderer;
     bool m_bindToImplThread;
 };
 
 PassOwnPtr<LayerRendererChromium> LayerRendererChromium::create(CCRendererClient* client, PassRefPtr<GraphicsContext3D> context, TextureUploaderOption textureUploaderSetting)
 {
     OwnPtr<LayerRendererChromium> layerRenderer(adoptPtr(new LayerRendererChromium(client, context, textureUploaderSetting)));
     if (!layerRenderer->initialize())
         return nullptr;
 
     return layerRenderer.release();
 }
 
 LayerRendererChromium::LayerRendererChromium(CCRendererClient* client,
                                              PassRefPtr<GraphicsContext3D> context,
                                              TextureUploaderOption textureUploaderSetting)
     : CCRenderer(client)
     , m_currentRenderPass(0)
     , m_currentManagedTexture(0)
     , m_offscreenFramebufferId(0)
     , m_sharedGeometryQuad(FloatRect(-0.5f, -0.5f, 1.0f, 1.0f))
     , m_context(context)
     , m_defaultRenderPass(0)
     , m_isViewportChanged(false)
     , m_isFramebufferDiscarded(false)
+    , m_visible(true)
     , m_textureUploaderSetting(textureUploaderSetting)
 {
     ASSERT(m_context.get());
 }
 
 class ContextLostCallbackAdapter : public GraphicsContext3D::ContextLostCallback {
 public:
     static PassOwnPtr<ContextLostCallbackAdapter> create(CCRendererClient* client)
     {
         return adoptPtr(new ContextLostCallbackAdapter(client));
@@ skipping 63 matching lines @@
     m_capabilities.usingTextureStorageExtension = extensions->supports("GL_EXT_texture_storage");
     if (m_capabilities.usingTextureStorageExtension)
         extensions->ensureEnabled("GL_EXT_texture_storage");
 
     m_capabilities.usingGpuMemoryManager = extensions->supports("GL_CHROMIUM_gpu_memory_manager");
     if (m_capabilities.usingGpuMemoryManager) {
         extensions->ensureEnabled("GL_CHROMIUM_gpu_memory_manager");
         Extensions3DChromium* extensions3DChromium = static_cast<Extensions3DChromium*>(extensions);
         extensions3DChromium->setGpuMemoryAllocationChangedCallbackCHROMIUM(LayerRendererGpuMemoryAllocationChangedCallbackAdapter::create(this));
     } else {
-        m_client->setContentsMemoryAllocationLimitBytes(TextureManager::highLimitBytes(viewportSize()));
+        m_client->setMemoryAllocationLimitBytes(TextureManager::highLimitBytes(viewportSize()));
     }
 
     m_capabilities.usingDiscardFramebuffer = extensions->supports("GL_CHROMIUM_discard_framebuffer");
     if (m_capabilities.usingDiscardFramebuffer)
         extensions->ensureEnabled("GL_CHROMIUM_discard_framebuffer");
 
     GLC(m_context, m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_capabilities.maxTextureSize));
     m_capabilities.bestTextureFormat = PlatformColor::bestTextureFormat(m_context.get());
 
     if (!initializeSharedObjects())
@@ skipping 20 matching lines @@
 
 void LayerRendererChromium::debugGLCall(GraphicsContext3D* context, const char* command, const char* file, int line)
 {
     unsigned long error = context->getError();
     if (error != GraphicsContext3D::NO_ERROR)
         LOG_ERROR("GL command failed: File: %s\n\tLine %d\n\tcommand: %s, error %x\n", file, line, command, static_cast<int>(error));
 }
 
 void LayerRendererChromium::setVisible(bool visible)
 {
-    if (!visible)
-        releaseRenderPassTextures();
+    if (m_visible == visible)
+        return;
+    m_visible = visible;
 
     // TODO: Replace setVisibilityCHROMIUM with an extension to explicitly manage front/backbuffers
     // crbug.com/116049
     if (m_capabilities.usingSetVisibility) {
         Extensions3DChromium* extensions3DChromium = static_cast<Extensions3DChromium*>(m_context->getExtensions());
         extensions3DChromium->setVisibilityCHROMIUM(visible);
     }
 }
 
 void LayerRendererChromium::releaseRenderPassTextures()
@@ skipping 867 matching lines @@
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE));
 
     GLC(context(), context()->useProgram(program->program()));
     GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
     drawTexturedQuad(drawMatrix, bounds.width(), bounds.height(), 1, sharedGeometryQuad(),
                                     program->vertexShader().matrixLocation(),
                                     program->fragmentShader().alphaLocation(),
                                     -1);
 }
 
+void LayerRendererChromium::setGpuMemoryAllocation(Extensions3DChromium::GpuMemoryAllocationCHROMIUM allocation)
+{
+    if (m_visible && !allocation.gpuResourceSizeInBytes)
+        return;
+
+    if (!allocation.suggestHaveBackbuffer && !m_visible)
+        discardFramebuffer();
+
+    if (!allocation.gpuResourceSizeInBytes) {
+        releaseRenderPassTextures();
+        m_client->releaseContentsTextures();
+        GLC(m_context, m_context->flush());
+    } else
+        m_client->setMemoryAllocationLimitBytes(allocation.gpuResourceSizeInBytes);
+}
+
 void LayerRendererChromium::finish()
 {
     TRACE_EVENT("LayerRendererChromium::finish", this, 0);
     m_context->finish();
 }
 
 bool LayerRendererChromium::swapBuffers(const IntRect& subBuffer)
 {
-    // FIXME: Remove this once gpu process supports ignoring swap buffers command while framebuffer is discarded.
-    //        Alternatively (preferably?), protect all cc code so as not to attempt a swap after a framebuffer discard.
-    if (m_isFramebufferDiscarded) {
-        m_client->setFullRootLayerDamage();
-        return false;
-    }
+    ASSERT(m_visible);
+    ASSERT(!m_isFramebufferDiscarded);
 
     TRACE_EVENT("LayerRendererChromium::swapBuffers", this, 0);
     // We're done! Time to swapbuffers!
 
     if (m_capabilities.usingPartialSwap) {
         // If supported, we can save significant bandwidth by only swapping the damaged/scissored region (clamped to the viewport)
         IntRect clippedSubBuffer = subBuffer;
         clippedSubBuffer.intersect(IntRect(IntPoint::zero(), viewportSize()));
         Extensions3DChromium* extensions3DChromium = static_cast<Extensions3DChromium*>(m_context->getExtensions());
         int flippedYPosOfRectBottom = viewportHeight() - clippedSubBuffer.y() - clippedSubBuffer.height();
@@ skipping 83 matching lines @@
     GLC(context, context->readPixels(rect.x(), rect.y(), rect.width(), rect.height(),
                                      GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, pixels));
 
     if (doWorkaround) {
         // Clean up.
         GLC(context, context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0));
         GLC(context, context->bindTexture(GraphicsContext3D::TEXTURE_2D, 0));
         GLC(context, context->deleteFramebuffer(temporaryFBO));
         GLC(context, context->deleteTexture(temporaryTexture));
     }
+
+    if (!m_visible) {
+        TRACE_EVENT0("cc", "LayerRendererChromium::getFramebufferPixels dropping resources after readback");
+        discardFramebuffer();
+        releaseRenderPassTextures();
+        m_client->releaseContentsTextures();
+        GLC(m_context, m_context->flush());
+    }
 }
 
 bool LayerRendererChromium::getFramebufferTexture(ManagedTexture* texture, const IntRect& deviceRect)
 {
     if (!texture->reserve(deviceRect.size(), GraphicsContext3D::RGB))
         return false;
 
     RefPtr<CCGraphicsContext> ccContext = CCGraphicsContext::create3D(m_context);
     texture->bindTexture(ccContext.get(), m_implTextureAllocator.get());
     GLC(m_context, m_context->copyTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, texture->format(),
@@ skipping 381 matching lines @@
 }
 
 bool LayerRendererChromium::isContextLost()
 {
     return (m_context.get()->getExtensions()->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR);
 }
 
 } // namespace WebCore
 
 #endif // USE(ACCELERATED_COMPOSITING)