Mailbox support for texture layers.

cc/texture_layer.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/texture_layer.h"
 
 #include "cc/layer_tree_host.h"
 #include "cc/texture_layer_client.h"
 #include "cc/texture_layer_impl.h"
+#include "cc/thread.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
-#include "third_party/khronos/GLES2/gl2.h"
 
 namespace cc {
 
+static void runCallback(const base::Callback<void(unsigned)>& callback, unsigned syncPoint) {

[danakj, 2013/01/02 20:09:44]

This one would be runCallbackOnMainThread (it's always on the main thread).

+    callback.Run(syncPoint);
+}
+
+static void runCallbackOnMain(Thread *mainThread, const base::Callback<void(unsigned)>& callback, unsigned syncPoint) {

[danakj, 2013/01/02 20:09:44]

This would postCallbackToMainThread or something.

+    mainThread->postTask(base::Bind(&runCallback, callback, syncPoint));
+}
+
 scoped_refptr<TextureLayer> TextureLayer::create(TextureLayerClient* client)
 {
-    return scoped_refptr<TextureLayer>(new TextureLayer(client));
+    return scoped_refptr<TextureLayer>(new TextureLayer(client, false));
 }
 
-TextureLayer::TextureLayer(TextureLayerClient* client)
+scoped_refptr<TextureLayer> TextureLayer::createForMailbox()
+{
+    return scoped_refptr<TextureLayer>(new TextureLayer(0, true));
+}
+
+TextureLayer::TextureLayer(TextureLayerClient* client, bool usesMailbox)
     : Layer()
     , m_client(client)
+    , m_usesMailbox(usesMailbox)
     , m_flipped(true)
     , m_uvRect(0, 0, 1, 1)
     , m_premultipliedAlpha(true)
     , m_rateLimitContext(false)
     , m_contextLost(false)
     , m_textureId(0)
     , m_contentCommitted(false)
 {
   m_vertexOpacity[0] = 1.0f;
   m_vertexOpacity[1] = 1.0f;
   m_vertexOpacity[2] = 1.0f;
   m_vertexOpacity[3] = 1.0f;
 }
 
 TextureLayer::~TextureLayer()
 {
     if (layerTreeHost()) {
         if (m_textureId)
             layerTreeHost()->acquireLayerTextures();
         if (m_rateLimitContext && m_client)
             layerTreeHost()->stopRateLimiter(m_client->context());
     }
+    if (!m_contentCommitted && !m_mailboxName.empty())
+        m_mailboxReleaseCallback.Run(0);
 }
 
 scoped_ptr<LayerImpl> TextureLayer::createLayerImpl(LayerTreeImpl* treeImpl)
 {
-    return TextureLayerImpl::create(treeImpl, m_layerId).PassAs<LayerImpl>();
+    return TextureLayerImpl::create(treeImpl, m_layerId, m_usesMailbox).PassAs<LayerImpl>();
 }
 
 void TextureLayer::setFlipped(bool flipped)
 {
     m_flipped = flipped;
     setNeedsCommit();
 }
 
 void TextureLayer::setUVRect(const gfx::RectF& rect)
 {
@@ skipping 25 matching lines @@
 void TextureLayer::setRateLimitContext(bool rateLimit)
 {
     if (!rateLimit && m_rateLimitContext && m_client && layerTreeHost())
         layerTreeHost()->stopRateLimiter(m_client->context());
 
     m_rateLimitContext = rateLimit;
 }
 
 void TextureLayer::setTextureId(unsigned id)
 {
+    DCHECK(!m_usesMailbox);
     if (m_textureId == id)
         return;
     if (m_textureId && layerTreeHost())
         layerTreeHost()->acquireLayerTextures();
     m_textureId = id;
     setNeedsCommit();
 }
 
+void TextureLayer::setTextureMailbox(const std::string& mailboxName, const base::Callback<void(unsigned)>& callback)
+{
+    DCHECK(m_usesMailbox);
+    DCHECK(mailboxName.empty() == callback.is_null());
+    if (m_mailboxName.compare(mailboxName) == 0)
+        return;
+    // If we never commited the mailbox, we need to release it here
+    if (!m_contentCommitted && !m_mailboxName.empty())
+        m_mailboxReleaseCallback.Run(0);
+    m_mailboxReleaseCallback = callback;
+    m_mailboxName = mailboxName;
+
+    setNeedsCommit();
+}
+
 void TextureLayer::willModifyTexture()
 {
     if (layerTreeHost() && (drawsContent() || m_contentCommitted)) {
         layerTreeHost()->acquireLayerTextures();
         m_contentCommitted = false;
     }
 }
 
 void TextureLayer::setNeedsDisplayRect(const gfx::RectF& dirtyRect)
 {
     Layer::setNeedsDisplayRect(dirtyRect);
 
     if (m_rateLimitContext && m_client && layerTreeHost() && drawsContent())
         layerTreeHost()->startRateLimiter(m_client->context());
 }
 
 void TextureLayer::setLayerTreeHost(LayerTreeHost* host)
 {
     if (m_textureId && layerTreeHost() && host != layerTreeHost())
         layerTreeHost()->acquireLayerTextures();
     Layer::setLayerTreeHost(host);
 }
 
 bool TextureLayer::drawsContent() const
 {
-    return (m_client || m_textureId) && !m_contextLost && Layer::drawsContent();
+    return (m_client || m_textureId || !m_mailboxName.empty()) && !m_contextLost && Layer::drawsContent();
 }
 
 void TextureLayer::update(ResourceUpdateQueue& queue, const OcclusionTracker*, RenderingStats&)
 {
     if (m_client) {
         m_textureId = m_client->prepareTexture(queue);
         m_contextLost = m_client->context()->getGraphicsResetStatusARB() != GL_NO_ERROR;
     }
 
     m_needsDisplay = false;
 }
 
 void TextureLayer::pushPropertiesTo(LayerImpl* layer)
 {
     Layer::pushPropertiesTo(layer);
 
     TextureLayerImpl* textureLayer = static_cast<TextureLayerImpl*>(layer);
     textureLayer->setFlipped(m_flipped);
     textureLayer->setUVRect(m_uvRect);
     textureLayer->setVertexOpacity(m_vertexOpacity);
     textureLayer->setPremultipliedAlpha(m_premultipliedAlpha);
-    textureLayer->setTextureId(m_textureId);
+    if (m_usesMailbox) {
+        Thread* mainThread = layerTreeHost()->proxy()->mainThread();
+        textureLayer->setTextureMailbox(m_mailboxName, base::Bind(&runCallbackOnMain, mainThread, m_mailboxReleaseCallback));
+    } else {
+        textureLayer->setTextureId(m_textureId);
+    }
     m_contentCommitted = drawsContent();
 }
 
 bool TextureLayer::blocksPendingCommit() const
 {
     // Double-buffered texture layers need to be blocked until they can be made
     // triple-buffered.  Single-buffered layers already prevent draws, so
     // can block too for simplicity.
     return true;
 }
 
 }  // namespace cc