Move sync point from TransferResourceList to individual TransferResources

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 "cc/resource_provider.h"
 
 #include <limits.h>
 
 #include "base/debug/alias.h"
 #include "base/hash_tables.h"
@@ skipping 645 matching lines @@
 }
 
 const ResourceProvider::ResourceIdMap& ResourceProvider::getChildToParentMap(int child) const
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ChildMap::const_iterator it = m_children.find(child);
     DCHECK(it != m_children.end());
     return it->second.childToParentMap;
 }
 
-void ResourceProvider::prepareSendToParent(const ResourceIdArray& resources, TransferableResourceList* list)
+void ResourceProvider::prepareSendToParent(const ResourceIdArray& resources, TransferableResourceArray* list)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    list->sync_point = 0;
-    list->resources.clear();
+    list->clear();
     WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
+    bool needSyncPoint = false;
     for (ResourceIdArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
         TransferableResource resource;
         if (transferResource(context3d, *it, &resource)) {
+            if (!resource.sync_point)
+                needSyncPoint = true;
             m_resources.find(*it)->second.exported = true;
-            list->resources.push_back(resource);
+            list->push_back(resource);
         }
     }
-    if (list->resources.size())
-        list->sync_point = context3d->insertSyncPoint();
+    if (needSyncPoint) {
+        unsigned int syncPoint = context3d->insertSyncPoint();
+        for (TransferableResourceArray::iterator it = list->begin(); it != list->end(); ++it) {
+            if (!it->sync_point)
+                it->sync_point = syncPoint;
+        }
+    }
 }
 
-void ResourceProvider::prepareSendToChild(int child, const ResourceIdArray& resources, TransferableResourceList* list)
+void ResourceProvider::prepareSendToChild(int child, const ResourceIdArray& resources, TransferableResourceArray* list)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    list->sync_point = 0;
-    list->resources.clear();
+    list->clear();
     WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
     Child& childInfo = m_children.find(child)->second;
+    bool needSyncPoint = false;
     for (ResourceIdArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
         TransferableResource resource;
         if (!transferResource(context3d, *it, &resource))
             NOTREACHED();
+        if (!resource.sync_point)
+            needSyncPoint = true;
         DCHECK(childInfo.parentToChildMap.find(*it) != childInfo.parentToChildMap.end());
         resource.id = childInfo.parentToChildMap[*it];
         childInfo.parentToChildMap.erase(*it);
         childInfo.childToParentMap.erase(resource.id);
-        list->resources.push_back(resource);
+        list->push_back(resource);
         deleteResource(*it);
     }
-    if (list->resources.size())
-        list->sync_point = context3d->insertSyncPoint();
+    if (needSyncPoint) {
+        unsigned int syncPoint = context3d->insertSyncPoint();
+        for (TransferableResourceArray::iterator it = list->begin(); it != list->end(); ++it) {
+            if (!it->sync_point)
+                it->sync_point = syncPoint;
+        }
+    }
 }
 
-void ResourceProvider::receiveFromChild(int child, const TransferableResourceList& resources)
+void ResourceProvider::receiveFromChild(int child, const TransferableResourceArray& resources)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
-    if (resources.sync_point) {
+    Child& childInfo = m_children.find(child)->second;
+    for (TransferableResourceArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
+        unsigned textureId;
         // NOTE: If the parent is a browser and the child a renderer, the parent
         // is not supposed to have its context wait, because that could induce
         // deadlocks and/or security issues. The caller is responsible for
         // waiting asynchronously, and resetting sync_point before calling this.
         // However if the parent is a renderer (e.g. browser tag), it may be ok
         // (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;
+        if (it->sync_point)
+            GLC(context3d, context3d->waitSyncPoint(it->sync_point));

[danakj, 2013/02/26 16:01:28]

To make sure we're on the same page: Is next step to make this store the mailbox
on the resource with the sync point instead of waiting and consuming it here?
Probably by replacing this function with createResourceFromTextureMailbox?

[piman, 2013/02/26 23:09:27]

Something along those lines, merging the 2 paths has some benefits. I don't
think the callback mechanism scales very well will 100s of resources (both in
terms of run-time perf, memory and in terms of complexity), but we can figure
something out. Mostly for this CL I wanted to unblock the hack in the ÜC CL, the
rest can be optimized/simplified under the hood as a follow-up.

         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, it->size, it->format, it->filter);
         resource.mailbox.SetName(it->mailbox);
         // Don't allocate a texture for a child.
         resource.allocated = true;
         m_resources[id] = resource;
         childInfo.parentToChildMap[id] = it->id;
         childInfo.childToParentMap[it->id] = id;
     }
 }
 
-void ResourceProvider::receiveFromParent(const TransferableResourceList& resources)
+void ResourceProvider::receiveFromParent(const TransferableResourceArray& resources)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     WebGraphicsContext3D* context3d = m_outputSurface->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) {
+    for (TransferableResourceArray::const_iterator it = resources.begin(); it != 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;
         DCHECK(resource->mailbox.Equals(it->mailbox));
         if (resource->glId) {
+          if (it->sync_point)
+            GLC(context3d, context3d->waitSyncPoint(it->sync_point));
           GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
           GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, it->mailbox.name));
         } else {
-          resource->mailbox = TextureMailbox(resource->mailbox.name(), resource->mailbox.callback(), resources.sync_point);
+          resource->mailbox = TextureMailbox(resource->mailbox.name(), resource->mailbox.callback(), it->sync_point);
         }
         if (resource->markedForDeletion)
             deleteResourceInternal(mapIterator);
     }
 }
 
 bool ResourceProvider::transferResource(WebGraphicsContext3D* context, ResourceId id, TransferableResource* resource)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     WebGraphicsContext3D* context3d = m_outputSurface->context3d();
@@ skipping 13 matching lines @@
 
     if (source->mailbox.IsEmpty()) {
         GLC(context3d, context3d->genMailboxCHROMIUM(resource->mailbox.name));
         source->mailbox.SetName(resource->mailbox);
     } else
         resource->mailbox = source->mailbox.name();
 
     if (source->glId) {
         GLC(context, context->bindTexture(GL_TEXTURE_2D, source->glId));
         GLC(context, context->produceTextureCHROMIUM(GL_TEXTURE_2D, resource->mailbox.name));
-    } else if (source->mailbox.sync_point()) {
-        GLC(context3d, context3d->waitSyncPoint(source->mailbox.sync_point()));
+    } else {
+        resource->sync_point = source->mailbox.sync_point();
         source->mailbox.ResetSyncPoint();
     }
     return true;
 }
 
 void ResourceProvider::acquirePixelBuffer(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
@@ skipping 320 matching lines @@
     resource->enableReadLockFences = enable;
 }
 
 void ResourceProvider::setOffscreenContextProvider(scoped_refptr<cc::ContextProvider> offscreenContextProvider) {
   if (offscreenContextProvider)
       offscreenContextProvider->BindToCurrentThread();
   m_offscreenContextProvider = offscreenContextProvider;
 }
 
 }  // namespace cc