[cc] Mailbox Output Surface Support

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 <set>
 #include <string>
 #include <vector>
 
@@ skipping 122 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")
                                            && settings().useMemoryManagement;
     if (m_capabilities.usingGpuMemoryManager)
         m_context->setMemoryAllocationChangedCallbackCHROMIUM(this);
 
-    m_capabilities.usingDiscardBackbuffer = extensions.count("GL_CHROMIUM_discard_backbuffer");
-
     m_capabilities.usingEglImage = extensions.count("GL_OES_EGL_image_external");
 
     m_capabilities.maxTextureSize = m_resourceProvider->maxTextureSize();
     m_capabilities.bestTextureFormat = m_resourceProvider->bestTextureFormat();
 
     // The updater can access textures while the GLRenderer is using them.
     m_capabilities.allowPartialTextureUpdates = true;
 
     // Check for texture fast paths. Currently we always use MO8 textures,
     // so we only need to avoid POT textures if we have an NPOT fast-path.
@@ skipping 95 matching lines @@
 
     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;
-        m_context->reshape(viewportWidth(), viewportHeight());
+        m_outputSurface->Reshape(gfx::Size(viewportWidth(), viewportHeight()));
     }
 
     makeContextCurrent();
     // Bind the common vertex attributes used for drawing all the layers.
     m_sharedGeometry->prepareForDraw();
 
     GLC(m_context, m_context->disable(GL_DEPTH_TEST));
     GLC(m_context, m_context->disable(GL_CULL_FACE));
     GLC(m_context, m_context->colorMask(true, true, true, true));
     GLC(m_context, m_context->enable(GL_BLEND));
@@ skipping 938 matching lines @@
 {
     m_currentFramebufferLock.reset();
     m_swapBufferRect.Union(gfx::ToEnclosingRect(frame.rootDamageRect));
 
     GLC(m_context, m_context->disable(GL_BLEND));
     m_blendShadow = false;
 
     if (settings().compositorFrameMessage) {
         CompositorFrame compositor_frame;
         compositor_frame.metadata = m_client->makeCompositorFrameMetadata();
-        compositor_frame.gl_frame_data.reset(new GLFrameData());
-        // FIXME: Fill in GLFrameData when we implement swapping with it.
         m_outputSurface->SendFrameToParentCompositor(&compositor_frame);
     }
 }
 
 void GLRenderer::finishDrawingQuadList()
 {
     flushTextureQuadCache();
 }
 
 bool GLRenderer::flippedFramebuffer() const
@@ skipping 105 matching lines @@
     DCHECK(m_visible);
     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());
+        m_outputSurface->PostSubBuffer(gfx::Rect(m_swapBufferRect.x(), flippedYPosOfRectBottom, m_swapBufferRect.width(), m_swapBufferRect.height()));
     } else {
-        // Note that currently this has the same effect as swapBuffers; we should
-        // consider exposing a different entry point on WebGraphicsContext3D.
-        m_context->prepareTexture();
+        m_outputSurface->SwapBuffers();
     }
 
     m_swapBufferRect = gfx::Rect();
 
     // We don't have real fences, so we mark read fences as passed
     // assuming a double-buffered GPU pipeline. A texture can be
     // written to after one full frame has past since it was last read.
     if (m_lastSwapFence)
         static_cast<SimpleSwapFence*>(m_lastSwapFence.get())->setHasPassed();
     m_lastSwapFence = m_resourceProvider->getReadLockFence();
     m_resourceProvider->setReadLockFence(new SimpleSwapFence());
 
     return true;
 }
 
+void GLRenderer::receiveCompositorFrameAck(const CompositorFrameAck& ack) {
+    onSwapBuffersComplete();
+}
+
 void GLRenderer::onSwapBuffersComplete()
 {
     m_client->onSwapBuffersComplete();
 }
 
 void GLRenderer::onMemoryAllocationChanged(WebGraphicsMemoryAllocation allocation)
 {
     // Just ignore the memory manager when it says to set the limit to zero
     // bytes. This will happen when the memory manager thinks that the renderer
     // is not visible (which the renderer knows better).
@@ skipping 44 matching lines @@
         m_resourceProvider->releaseCachedData();
         GLC(m_context, m_context->flush());
     }
 }
 
 void GLRenderer::discardBackbuffer()
 {
     if (m_isBackbufferDiscarded)
         return;
 
-    if (!m_capabilities.usingDiscardBackbuffer)
-        return;
+    m_outputSurface->DiscardBackbuffer();
 
-    m_context->discardBackbufferCHROMIUM();
     m_isBackbufferDiscarded = true;
 
     // Damage tracker needs a full reset every time framebuffer is discarded.
     m_client->setFullRootLayerDamage();
 }
 
 void GLRenderer::ensureBackbuffer()
 {
     if (!m_isBackbufferDiscarded)
         return;
 
-    if (!m_capabilities.usingDiscardBackbuffer)
-        return;
-
-    m_context->ensureBackbufferCHROMIUM();
+    m_outputSurface->EnsureBackbuffer();
     m_isBackbufferDiscarded = false;
 }
 
 void GLRenderer::onContextLost()
 {
     m_client->didLoseOutputSurface();
 }
 
 
 void GLRenderer::getFramebufferPixels(void *pixels, const gfx::Rect& rect)
@@ skipping 83 matching lines @@
     DCHECK(texture->id());
     frame.currentRenderPass = 0;
     frame.currentTexture = texture;
 
     return bindFramebufferToTexture(frame, texture, viewportRect);
 }
 
 void GLRenderer::bindFramebufferToOutputSurface(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
-    GLC(m_context, m_context->bindFramebuffer(GL_FRAMEBUFFER, 0));
+    m_outputSurface->BindFramebuffer();
 }
 
 bool GLRenderer::bindFramebufferToTexture(DrawingFrame& frame, const ScopedResource* texture, const gfx::Rect& framebufferRect)
 {
     DCHECK(texture->id());
 
     GLC(m_context, m_context->bindFramebuffer(GL_FRAMEBUFFER, m_offscreenFramebufferId));
     m_currentFramebufferLock = make_scoped_ptr(new ResourceProvider::ScopedWriteLockGL(m_resourceProvider, texture->id()));
     unsigned textureId = m_currentFramebufferLock->textureId();
     GLC(m_context, m_context->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureId, 0));
@@ skipping 284 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc