Mailbox support for texture layers.

cc/texture_layer_impl.cc

 // Copyright 2011 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_impl.h"
 
 #include "base/stringprintf.h"
+#include "cc/layer_tree_impl.h"
+#include "cc/mailbox_release_client.h"
 #include "cc/quad_sink.h"
 #include "cc/renderer.h"
 #include "cc/texture_draw_quad.h"
 
+#include <public/WebGraphicsContext3D.h>

[danakj, 2012/12/20 02:16:19]

use "third_party/WebKit/..."

[alexst (slow to review), 2012/12/21 14:15:21]

Goes away with base::bind
On 2012/12/20 02:16:19, danakj wrote:

+
 namespace cc {
 
-TextureLayerImpl::TextureLayerImpl(LayerTreeImpl* treeImpl, int id)
+TextureLayerImpl::TextureLayerImpl(LayerTreeImpl* treeImpl, int id, MailboxReleaseClient* client)
     : LayerImpl(treeImpl, id)
     , m_textureId(0)
     , m_externalTextureResource(0)
     , m_premultipliedAlpha(true)
     , m_flipped(true)
     , m_uvRect(0, 0, 1, 1)
+    , m_newMailboxPending(false)
+    , m_mailboxClient(client)
 {
   m_vertexOpacity[0] = 1.0f;
   m_vertexOpacity[1] = 1.0f;
   m_vertexOpacity[2] = 1.0f;
   m_vertexOpacity[3] = 1.0f;
 }
 
 TextureLayerImpl::~TextureLayerImpl()
 {

[piman, 2012/12/20 02:14:21]

You probably need to do more here, for the case where the TextureLayer was
removed from the tree, and so this gets deleted during the commit. You won't get
any other willDraw, so you can't properly return the texture to the client.

[alexst (slow to review), 2012/12/21 14:15:21]

Done.

 }
 
+void TextureLayerImpl::setTextureMailbox(const std::string& mailboxName)
+{
+    // Same mailbox name was commited, nothing to do
+    if (m_lastMailbox.compare(mailboxName) == 0)
+      return;
+    m_newMailbox = mailboxName;
+    m_newMailboxPending = true;
+}
+
 void TextureLayerImpl::willDraw(ResourceProvider* resourceProvider)
 {
+    if (m_mailboxClient) {
+        handleMailboxResources(resourceProvider);
+        return;
+    }
     if (!m_textureId)
         return;
     DCHECK(!m_externalTextureResource);
     m_externalTextureResource = resourceProvider->createResourceFromExternalTexture(m_textureId);
 }
 
 void TextureLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
 {
     if (!m_externalTextureResource)
         return;
 
     SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
     appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
 
     gfx::Rect quadRect(gfx::Point(), contentBounds());
     gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
     quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, m_premultipliedAlpha, m_uvRect, m_vertexOpacity, m_flipped);
 
     // Perform explicit clipping on a quad to avoid setting a scissor later.
     if (sharedQuadState->is_clipped && quad->PerformClipping())
         sharedQuadState->is_clipped = false;
     if (!quad->rect.IsEmpty())
         quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 }
 
 void TextureLayerImpl::didDraw(ResourceProvider* resourceProvider)
 {
+    if (m_mailboxClient)
+        return;
     if (!m_externalTextureResource)
         return;
     // FIXME: the following assert will not be true when sending resources to a
     // parent compositor. A synchronization scheme (double-buffering or
     // pipelining of updates) for the client will need to exist to solve this.
     DCHECK(!resourceProvider->inUseByConsumer(m_externalTextureResource));
     resourceProvider->deleteResource(m_externalTextureResource);
     m_externalTextureResource = 0;
 }
 
@@ skipping 15 matching lines @@
 {
     m_textureId = 0;
     m_externalTextureResource = 0;
 }
 
 const char* TextureLayerImpl::layerTypeAsString() const
 {
     return "TextureLayer";
 }
 
+void TextureLayerImpl::handleMailboxResources(ResourceProvider* resourceProvider)
+{
+    if (!m_newMailboxPending)
+        return;
+
+    if (m_externalTextureResource) {
+        DCHECK(!resourceProvider->inUseByConsumer(m_externalTextureResource));
+        resourceProvider->deleteResource(m_externalTextureResource);
+        m_externalTextureResource = 0;
+        WebKit::WebGraphicsContext3D* context =
+            layerTreeImpl()->resource_provider()->graphicsContext3D();
+
+        m_mailboxClient->mailboxReleased(m_lastMailbox, context->insertSyncPoint());

[piman, 2012/12/20 02:14:21]

We need to be clear about which thread the client is called on. Right now it
would be called on the main thread in some cases and on the impl thread in other
cases, and that probably isn't viable.

[alexst (slow to review), 2012/12/21 14:15:21]

That's one of the things I wanted to discuss.

Like you said, there will be cases when the callback needs to be triggered from
both main and impl. For example, when a mailbox is set on main and then set
again before a commit happened, in that case we'll need to release the old
buffer on main, whereas commited buffers get released on impl.

I could try something along the lines of wrapping the original callback to post
taks on main thread inside texture_layer and pass that on to layer_impl, or we
could document this as callback coming from any thread and leave it up to the
user to proxy it to the desired thread. That's what I am doing now in my test.
What are your thoughts on either of these?

On 2012/12/20 02:14:21, piman wrote:

+    }
+    if (m_newMailbox.size()) {
+        m_externalTextureResource = resourceProvider->createResourceFromTextureMailbox(m_newMailbox);
+        m_newMailboxPending = false;
+    }
+    m_lastMailbox = m_newMailbox;
+    m_newMailbox.clear();
+}
+
 }  // namespace cc