Cosmetic cleanup to texture_layer mailboxes.

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"
 
 namespace cc {
 
-static void runCallbackOnMainThread(const TextureLayer::MailboxCallback& callback, unsigned syncPoint)
+static void runCallbackOnMainThread(const TextureMailbox::ReleaseCallback& callback, unsigned syncPoint)
 {
     callback.Run(syncPoint);
 }
 
-static void postCallbackToMainThread(Thread *mainThread, const TextureLayer::MailboxCallback& callback, unsigned syncPoint)
+static void postCallbackToMainThread(Thread *mainThread, const TextureMailbox::ReleaseCallback& callback, unsigned syncPoint)
 {
     mainThread->postTask(base::Bind(&runCallbackOnMainThread, callback, syncPoint));
 }
 
 scoped_refptr<TextureLayer> TextureLayer::create(TextureLayerClient* client)
 {
     return scoped_refptr<TextureLayer>(new TextureLayer(client, false));
 }
 
 scoped_refptr<TextureLayer> TextureLayer::createForMailbox()
@@ skipping 20 matching lines @@
 }
 
 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);
+    if (!m_contentCommitted)
+        m_textureMailbox.RunReleaseCallback(0);
 }
 
 scoped_ptr<LayerImpl> TextureLayer::createLayerImpl(LayerTreeImpl* treeImpl)
 {
     return TextureLayerImpl::create(treeImpl, m_layerId, m_usesMailbox).PassAs<LayerImpl>();
 }
 
 void TextureLayer::setFlipped(bool flipped)
 {
     m_flipped = flipped;
@@ skipping 39 matching lines @@
 {
     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 MailboxCallback& callback)
+void TextureLayer::setTextureMailbox(const TextureMailbox& mailbox)
 {
     DCHECK(m_usesMailbox);
-    DCHECK(mailboxName.empty() == callback.is_null());
-    if (m_mailboxName.compare(mailboxName) == 0)
+    if (m_textureMailbox.Equals(mailbox))
         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;
+    if (!m_contentCommitted)
+        m_textureMailbox.RunReleaseCallback(0);
+    m_textureMailbox = mailbox;
 
     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_mailboxName.empty()) && !m_contextLost && Layer::drawsContent();
+    return (m_client || m_textureId || !m_textureMailbox.IsEmpty()) && !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);
     if (m_usesMailbox) {
         Thread* mainThread = layerTreeHost()->proxy()->mainThread();
-        textureLayer->setTextureMailbox(m_mailboxName, base::Bind(&postCallbackToMainThread, mainThread, m_mailboxReleaseCallback));
+        TextureMailbox::ReleaseCallback callback;
+        if (!m_textureMailbox.IsEmpty())
+          callback = base::Bind(&postCallbackToMainThread, mainThread, m_textureMailbox.callback());
+        textureLayer->setTextureMailbox(TextureMailbox(m_textureMailbox.name(), callback));
     } 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 drawsContent();
 }
 
 bool TextureLayer::canClipSelf() const
 {
     return true;
 }
 
 }  // namespace cc