Uber Comp: never change mailbox name associated with a texture object.

cc/resource_provider.cc

 // Copyright 2012 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 "config.h"
 
 #include "cc/resource_provider.h"
 
 #include <limits.h>
 
@@ skipping 56 matching lines @@
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , size()
     , format(0)
     , type(static_cast<ResourceType>(0))
 {
 }
 
-ResourceProvider::Resource::Resource(unsigned textureId, int pool, const gfx::Size& size, GLenum format)
+ResourceProvider::Resource::Resource(unsigned textureId, const Mailbox& mailbox, int pool, const gfx::Size& size, GLenum format)
     : glId(textureId)
+    , mailbox(mailbox)
     , pixels(0)
     , pool(pool)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , size(size)
     , format(format)
     , type(GLTexture)
@@ skipping 82 matching lines @@
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 
     if (m_useTextureUsageHint && hint == TextureUsageFramebuffer)
         GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE));
     if (m_useTextureStorageExt && isTextureFormatSupportedForStorage(format)) {
         GLenum storageFormat = textureToStorageFormat(format);
         GLC(context3d, context3d->texStorage2DEXT(GL_TEXTURE_2D, 1, storageFormat, size.width(), size.height()));
     } else
         GLC(context3d, context3d->texImage2D(GL_TEXTURE_2D, 0, format, size.width(), size.height(), 0, format, GL_UNSIGNED_BYTE, 0));
+
+    Mailbox mailbox;
+    GLC(context3d, context3d->genMailboxCHROMIUM(mailbox.name));

[piman, 2012/11/07 00:49:55]

I've been thinking about this more, and I'm leaning towards doing this (lazily)
in prepareSendToParent :
1- we don't pay the cost when not sending the resource - meaning, in particular,
we don't pay the cost when not using ubercomp.
2- we can batch the gen since we can know the number of mailboxes we'll need.

+
     ResourceId id = m_nextId++;
-    Resource resource(textureId, pool, size, format);
+    Resource resource(textureId, mailbox, pool, size, format);
     m_resources[id] = resource;
     return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::createBitmap(int pool, const gfx::Size& size)
 {
     DCHECK(Proxy::isImplThread());
 
     uint8_t* pixels = new uint8_t[size.width() * size.height() * 4];
 
     ResourceId id = m_nextId++;
     Resource resource(pixels, pool, size, GL_RGBA);
     m_resources[id] = resource;
     return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::createResourceFromExternalTexture(unsigned textureId)
 {
     DCHECK(Proxy::isImplThread());
-    DCHECK(m_context->context3D());
+    WebGraphicsContext3D* context3d = m_context->context3D();
+    DCHECK(context3d);
+
+    Mailbox mailbox;
+    GLC(context3d, context3d->genMailboxCHROMIUM(mailbox.name));

[piman, 2012/11/07 00:49:55]

We don't have to do this at all here, since we won't send these resources.

+
     ResourceId id = m_nextId++;
-    Resource resource(textureId, 0, gfx::Size(), 0);
+    Resource resource(textureId, mailbox, 0, gfx::Size(), 0);
     resource.external = true;
     m_resources[id] = resource;
     return id;
 }
 
 void ResourceProvider::deleteResource(ResourceId id)
 {
     DCHECK(Proxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
@@ skipping 316 matching lines @@
     return child;
 }
 
 void ResourceProvider::destroyChild(int child)
 {
     DCHECK(Proxy::isImplThread());
     ChildMap::iterator it = m_children.find(child);
     DCHECK(it != m_children.end());
     deleteOwnedResources(it->second.pool);
     m_children.erase(it);
-    trimMailboxDeque();
 }
 
 const ResourceProvider::ResourceIdMap& ResourceProvider::getChildToParentMap(int child) const
 {
     DCHECK(Proxy::isImplThread());
     ChildMap::const_iterator it = m_children.find(child);
     DCHECK(it != m_children.end());
     return it->second.childToParentMap;
 }
 
@@ skipping 61 matching lines @@
         // (and is simpler) to wait.
         GLC(context3d, context3d->waitSyncPoint(resources.sync_point));
     }
     Child& childInfo = m_children.find(child)->second;
     for (TransferableResourceArray::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         unsigned textureId;
         GLC(context3d, textureId = context3d->createTexture());
         GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, textureId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, it->mailbox.name));
         ResourceId id = m_nextId++;
-        Resource resource(textureId, childInfo.pool, it->size, it->format);
+        Resource resource(textureId, it->mailbox, childInfo.pool, it->size, it->format);
         m_resources[id] = resource;
-        m_mailboxes.push_back(it->mailbox);
         childInfo.parentToChildMap[id] = it->id;
         childInfo.childToParentMap[it->id] = id;
     }
 }
 
 void ResourceProvider::receiveFromParent(const TransferableResourceList& resources)
 {
     DCHECK(Proxy::isImplThread());
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
     if (resources.sync_point)
         GLC(context3d, context3d->waitSyncPoint(resources.sync_point));
     for (TransferableResourceArray::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         ResourceMap::iterator mapIterator = m_resources.find(it->id);
         DCHECK(mapIterator != m_resources.end());
         Resource* resource = &mapIterator->second;
         DCHECK(resource->exported);
         resource->exported = false;
         GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, it->mailbox.name));
-        m_mailboxes.push_back(it->mailbox);
         if (resource->markedForDeletion)
             deleteResourceInternal(mapIterator);
     }
 }
 
 bool ResourceProvider::transferResource(WebGraphicsContext3D* context, ResourceId id, TransferableResource* resource)
 {
     DCHECK(Proxy::isImplThread());
     ResourceMap::const_iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     const Resource* source = &it->second;
     DCHECK(!source->lockedForWrite);
     DCHECK(!source->lockForReadCount);
     DCHECK(!source->external);
     if (source->exported)
         return false;
     resource->id = id;
     resource->format = source->format;
     resource->size = source->size;
-    if (!m_mailboxes.empty()) {
-        resource->mailbox = m_mailboxes.front();
-        m_mailboxes.pop_front();
-    }
-    else
-        GLC(context, context->genMailboxCHROMIUM(resource->mailbox.name));
+    resource->mailbox = source->mailbox;
     GLC(context, context->bindTexture(GL_TEXTURE_2D, source->glId));
     GLC(context, context->produceTextureCHROMIUM(GL_TEXTURE_2D, resource->mailbox.name));
     return true;
 }
 
-void ResourceProvider::trimMailboxDeque()
-{
-    // Trim the mailbox deque to the maximum number of resources we may need to
-    // send.
-    // If we have a parent, any non-external resource not already transfered is
-    // eligible to be sent to the parent. Otherwise, all resources belonging to
-    // a child might need to be sent back to the child.
-    size_t maxMailboxCount = 0;
-    if (m_context->capabilities().hasParentCompositor) {
-        for (ResourceMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
-            if (!it->second.exported && !it->second.external)
-                ++maxMailboxCount;
-        }
-    } else {
-        base::hash_set<int> childPoolSet;
-        for (ChildMap::iterator it = m_children.begin(); it != m_children.end(); ++it)
-            childPoolSet.insert(it->second.pool);
-        for (ResourceMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
-            if (ContainsKey(childPoolSet, it->second.pool))
-                ++maxMailboxCount;
-        }
-    }
-    while (m_mailboxes.size() > maxMailboxCount)
-        m_mailboxes.pop_front();
-}
-
 void ResourceProvider::debugNotifyEnterZone(unsigned int zone)
 {
     g_debugZone = zone;
 }
 
 void ResourceProvider::debugNotifyLeaveZone()
 {
     g_debugZone = 0;
 }
 
 
 }  // namespace cc