Rename discardFramebufferEXT to discardBackbufferCHROMIUM to avoid collision with real discardFrame…

cc/gl_renderer.cc

 // Copyright 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/gl_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 56 matching lines @@
 
     return renderer.Pass();
 }
 
 GLRenderer::GLRenderer(RendererClient* client, ResourceProvider* resourceProvider)
     : DirectRenderer(client, resourceProvider)
     , m_offscreenFramebufferId(0)
     , m_sharedGeometryQuad(gfx::RectF(-0.5f, -0.5f, 1.0f, 1.0f))
     , m_context(resourceProvider->graphicsContext3D())
     , m_isViewportChanged(false)
-    , m_isFramebufferDiscarded(false)
-    , m_discardFramebufferWhenNotVisible(false)
+    , m_isBackbufferDiscarded(false)
+    , m_discardBackbufferWhenNotVisible(false)
     , m_isUsingBindUniform(false)
     , m_visible(true)
     , m_isScissorEnabled(false)
 {
     DCHECK(m_context);
 }
 
 bool GLRenderer::initialize()
 {
     if (!m_context->makeContextCurrent())
@@ skipping 23 matching lines @@
 
     m_capabilities.usingSetVisibility = extensions.count("GL_CHROMIUM_set_visibility");
 
     if (extensions.count("GL_CHROMIUM_iosurface"))
         DCHECK(extensions.count("GL_ARB_texture_rectangle"));
 
     m_capabilities.usingGpuMemoryManager = extensions.count("GL_CHROMIUM_gpu_memory_manager");
     if (m_capabilities.usingGpuMemoryManager)
         m_context->setMemoryAllocationChangedCallbackCHROMIUM(this);
 
-    m_capabilities.usingDiscardFramebuffer = extensions.count("GL_CHROMIUM_discard_framebuffer");
+    m_capabilities.usingDiscardBackbuffer = extensions.count("GL_CHROMIUM_discard_backbuffer");
 
     m_capabilities.usingEglImage = extensions.count("GL_OES_EGL_image_external");
 
     GLC(m_context, m_context->getIntegerv(GL_MAX_TEXTURE_SIZE, &m_capabilities.maxTextureSize));
     m_capabilities.bestTextureFormat = PlatformColor::bestTextureFormat(m_context, extensions.count("GL_EXT_texture_format_BGRA8888"));
 
     // The updater can access textures while the GLRenderer is using them.
     m_capabilities.allowPartialTextureUpdates = true;
 
     m_isUsingBindUniform = extensions.count("GL_CHROMIUM_bind_uniform_location");
@@ skipping 48 matching lines @@
     if (m_capabilities.usingSetVisibility)
         m_context->setVisibilityCHROMIUM(visible);
 }
 
 void GLRenderer::sendManagedMemoryStats(size_t bytesVisible, size_t bytesVisibleAndNearby, size_t bytesAllocated)
 {
     WebKit::WebGraphicsManagedMemoryStats stats;
     stats.bytesVisible = bytesVisible;
     stats.bytesVisibleAndNearby = bytesVisibleAndNearby;
     stats.bytesAllocated = bytesAllocated;
-    stats.backbufferRequested = !m_isFramebufferDiscarded;
+    stats.backbufferRequested = !m_isBackbufferDiscarded;
     m_context->sendManagedMemoryStatsCHROMIUM(&stats);
 }
 
 void GLRenderer::releaseRenderPassTextures()
 {
     m_renderPassTextures.clear();
 }
 
 void GLRenderer::viewportChanged()
 {
     m_isViewportChanged = true;
 }
 
 void GLRenderer::clearFramebuffer(DrawingFrame& frame)
 {
     // On DEBUG builds, opaque render passes are cleared to blue to easily see regions that were not drawn on the screen.
     if (frame.currentRenderPass->has_transparent_background)
         GLC(m_context, m_context->clearColor(0, 0, 0, 0));
     else
         GLC(m_context, m_context->clearColor(0, 0, 1, 1));
 
 #ifdef NDEBUG
     if (frame.currentRenderPass->has_transparent_background)
 #endif
         m_context->clear(GL_COLOR_BUFFER_BIT);
 }
 
 void GLRenderer::beginDrawingFrame(DrawingFrame& frame)
 {
-    // FIXME: Remove this once framebuffer is automatically recreated on first use
-    ensureFramebuffer();
+    // FIXME: Remove this once backbuffer is automatically recreated on first use
+    ensureBackbuffer();
 
     if (viewportSize().IsEmpty())
         return;
 
     TRACE_EVENT0("cc", "GLRenderer::drawLayers");
     if (m_isViewportChanged) {
         // Only reshape when we know we are going to draw. Otherwise, the reshape
         // can leave the window at the wrong size if we never draw and the proper
         // viewport size is never set.
         m_isViewportChanged = false;
@@ skipping 1002 matching lines @@
 
 void GLRenderer::finish()
 {
     TRACE_EVENT0("cc", "GLRenderer::finish");
     m_context->finish();
 }
 
 bool GLRenderer::swapBuffers()
 {
     DCHECK(m_visible);
-    DCHECK(!m_isFramebufferDiscarded);
+    DCHECK(!m_isBackbufferDiscarded);
 
     TRACE_EVENT0("cc", "GLRenderer::swapBuffers");
     // 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)
         m_swapBufferRect.Intersect(gfx::Rect(gfx::Point(), viewportSize()));
         int flippedYPosOfRectBottom = viewportHeight() - m_swapBufferRect.y() - m_swapBufferRect.height();
         m_context->postSubBufferCHROMIUM(m_swapBufferRect.x(), flippedYPosOfRectBottom, m_swapBufferRect.width(), m_swapBufferRect.height());
     } else {
@@ skipping 23 matching lines @@
             priorityCutoffValue(allocation.priorityCutoffWhenVisible),
             allocation.bytesLimitWhenNotVisible,
             priorityCutoffValue(allocation.priorityCutoffWhenNotVisible));
 
         if (allocation.enforceButDoNotKeepAsPolicy)
             m_client->enforceManagedMemoryPolicy(policy);
         else
             m_client->setManagedMemoryPolicy(policy);
     }
 
-    bool oldDiscardFramebufferWhenNotVisible = m_discardFramebufferWhenNotVisible;
-    m_discardFramebufferWhenNotVisible = !allocation.suggestHaveBackbuffer;
+    bool oldDiscardBackbufferWhenNotVisible = m_discardBackbufferWhenNotVisible;
+    m_discardBackbufferWhenNotVisible = !allocation.suggestHaveBackbuffer;
     enforceMemoryPolicy();
     if (allocation.enforceButDoNotKeepAsPolicy)
-        m_discardFramebufferWhenNotVisible = oldDiscardFramebufferWhenNotVisible;
+        m_discardBackbufferWhenNotVisible = oldDiscardBackbufferWhenNotVisible;
 }
 
 int GLRenderer::priorityCutoffValue(WebKit::WebGraphicsMemoryAllocation::PriorityCutoff priorityCutoff)
 {
     switch (priorityCutoff) {
     case WebKit::WebGraphicsMemoryAllocation::PriorityCutoffAllowNothing:
         return PriorityCalculator::allowNothingCutoff();
     case WebKit::WebGraphicsMemoryAllocation::PriorityCutoffAllowVisibleOnly:
         return PriorityCalculator::allowVisibleOnlyCutoff();
     case WebKit::WebGraphicsMemoryAllocation::PriorityCutoffAllowVisibleAndNearby:
         return PriorityCalculator::allowVisibleAndNearbyCutoff();
     case WebKit::WebGraphicsMemoryAllocation::PriorityCutoffAllowEverything:
         return PriorityCalculator::allowEverythingCutoff();
     }
     NOTREACHED();
     return 0;
 }
 
 void GLRenderer::enforceMemoryPolicy()
 {
     if (!m_visible) {
         TRACE_EVENT0("cc", "GLRenderer::enforceMemoryPolicy dropping resources");
         releaseRenderPassTextures();
-        if (m_discardFramebufferWhenNotVisible)
-            discardFramebuffer();
+        if (m_discardBackbufferWhenNotVisible)
+            discardBackbuffer();
         GLC(m_context, m_context->flush());
     }
 }
 
-void GLRenderer::discardFramebuffer()
+void GLRenderer::discardBackbuffer()
 {
-    if (m_isFramebufferDiscarded)
+    if (m_isBackbufferDiscarded)
         return;
 
-    if (!m_capabilities.usingDiscardFramebuffer)
+    if (!m_capabilities.usingDiscardBackbuffer)
         return;
 
-    // FIXME: Update attachments argument to appropriate values once they are no longer ignored.
-    m_context->discardFramebufferEXT(GL_TEXTURE_2D, 0, 0);
-    m_isFramebufferDiscarded = true;
+    m_context->discardBackbufferCHROMIUM();
+    m_isBackbufferDiscarded = true;
 
     // Damage tracker needs a full reset every time framebuffer is discarded.
     m_client->setFullRootLayerDamage();
 }
 
-void GLRenderer::ensureFramebuffer()
+void GLRenderer::ensureBackbuffer()
 {
-    if (!m_isFramebufferDiscarded)
+    if (!m_isBackbufferDiscarded)
         return;
 
-    if (!m_capabilities.usingDiscardFramebuffer)
+    if (!m_capabilities.usingDiscardBackbuffer)
         return;
 
-    m_context->ensureFramebufferCHROMIUM();
-    m_isFramebufferDiscarded = false;
+    m_context->ensureBackbufferCHROMIUM();
+    m_isBackbufferDiscarded = false;
 }
 
 void GLRenderer::onContextLost()
 {
     m_client->didLoseOutputSurface();
 }
 
 
 void GLRenderer::getFramebufferPixels(void *pixels, const gfx::Rect& rect)
 {
@@ skipping 389 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc