Rolls cc and webkit_compositor up to 127340

cc/CCPrioritizedTextureManager.cpp

 // 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 "CCPrioritizedTextureManager.h"
 
 #include "CCPrioritizedTexture.h"
 #include "CCPriorityCalculator.h"
+#include "CCProxy.h"
 #include "TraceEvent.h"
 #include <algorithm>
 
 using namespace std;
 
 namespace WebCore {
 
 CCPrioritizedTextureManager::CCPrioritizedTextureManager(size_t maxMemoryLimitBytes, int, int pool)
     : m_maxMemoryLimitBytes(maxMemoryLimitBytes)
     , m_memoryUseBytes(0)
@@ skipping 10 matching lines @@
 
     // Each remaining backing is a leaked opengl texture. We don't have the resourceProvider
     // to delete the textures at this time so clearMemory() needs to be called before this.
     while (m_backings.size() > 0)
         destroyBacking(*m_backings.begin(), 0);
 }
 
 void CCPrioritizedTextureManager::prioritizeTextures()
 {
     TRACE_EVENT0("cc", "CCPrioritizedTextureManager::prioritizeTextures");
+    ASSERT(CCProxy::isMainThread());
 
 #if !ASSERT_DISABLED
     assertInvariants();
 #endif
 
     // Sorting textures in this function could be replaced by a slightly
     // modified O(n) quick-select to partition textures rather than
     // sort them (if performance of the sort becomes an issue).
 
     TextureVector& sortedTextures = m_tempTextureVector;
@@ skipping 59 matching lines @@
     sortedBackings.clear();
 
 #if !ASSERT_DISABLED
     assertInvariants();
     ASSERT(memoryAboveCutoffBytes() <= maxMemoryLimitBytes());
 #endif
 }
 
 void CCPrioritizedTextureManager::clearPriorities()
 {
+    ASSERT(CCProxy::isMainThread());
     for (TextureSet::iterator it = m_textures.begin(); it != m_textures.end(); ++it) {
         // FIXME: We should remove this and just set all priorities to
         //        CCPriorityCalculator::lowestPriority() once we have priorities
         //        for all textures (we can't currently calculate distances for
         //        off-screen textures).
         (*it)->setRequestPriority(CCPriorityCalculator::lingeringPriority((*it)->requestPriority()));
     }
 }
 
 bool CCPrioritizedTextureManager::requestLate(CCPrioritizedTexture* texture)
 {
+    ASSERT(CCProxy::isMainThread());
+
     // This is already above cutoff, so don't double count it's memory below.
     if (texture->isAbovePriorityCutoff())
         return true;
 
     if (CCPriorityCalculator::priorityIsLower(texture->requestPriority(), m_priorityCutoff))
         return false;
 
     size_t newMemoryBytes = m_memoryAboveCutoffBytes + texture->bytes();
     if (newMemoryBytes > m_memoryAvailableBytes)
         return false;
 
     m_memoryAboveCutoffBytes = newMemoryBytes;
     texture->setAbovePriorityCutoff(true);
     if (texture->backing()) {
         m_backings.remove(texture->backing());
         m_backings.add(texture->backing());
     }
     return true;
 }
 
 void CCPrioritizedTextureManager::acquireBackingTextureIfNeeded(CCPrioritizedTexture* texture, CCResourceProvider* resourceProvider)
 {
+    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
     ASSERT(!texture->isSelfManaged());
     ASSERT(texture->isAbovePriorityCutoff());
     if (texture->backing() || !texture->isAbovePriorityCutoff())
         return;
 
     // Find a backing below, by either recycling or allocating.
     CCPrioritizedTexture::Backing* backing = 0;
 
     // First try to recycle
     for (BackingSet::iterator it = m_backings.begin(); it != m_backings.end(); ++it) {
@@ skipping 14 matching lines @@
     // Move the used backing texture to the end of the eviction list.
     if (backing->owner())
         backing->owner()->unlink();
     texture->link(backing);
     m_backings.remove(backing);
     m_backings.add(backing);
 }
 
 void CCPrioritizedTextureManager::reduceMemory(size_t limitBytes, CCResourceProvider* resourceProvider)
 {
+    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
     if (memoryUseBytes() <= limitBytes)
         return;
     // Destroy backings until we are below the limit,
     // or until all backings remaining are above the cutoff.
     while (memoryUseBytes() > limitBytes && m_backings.size() > 0) {
         BackingSet::iterator it = m_backings.begin();
         if ((*it)->owner() && (*it)->owner()->isAbovePriorityCutoff())
             break;
         destroyBacking((*it), resourceProvider);
     }
 }
 
 void CCPrioritizedTextureManager::reduceMemory(CCResourceProvider* resourceProvider)
 {
+    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
     reduceMemory(m_memoryAvailableBytes, resourceProvider);
     ASSERT(memoryUseBytes() <= maxMemoryLimitBytes());
 
     // We currently collect backings from deleted textures for later recycling.
     // However, if we do that forever we will always use the max limit even if
     // we really need very little memory. This should probably be solved by reducing the
     // limit externally, but until then this just does some "clean up" of unused
     // backing textures (any more than 10%).
     size_t wastedMemory = 0;
     for (BackingSet::iterator it = m_backings.begin(); it != m_backings.end(); ++it) {
@@ skipping 21 matching lines @@
 void CCPrioritizedTextureManager::allBackingTexturesWereDeleted()
 {
     // Same as clearAllMemory, except all our textures were already
     // deleted externally, so we don't delete them. Passing no
     // resourceProvider results in leaking the (now invalid) texture ids.
     clearAllMemory(0);
 }
 
 void CCPrioritizedTextureManager::registerTexture(CCPrioritizedTexture* texture)
 {
+    ASSERT(CCProxy::isMainThread());
     ASSERT(texture);
     ASSERT(!texture->textureManager());
     ASSERT(!texture->backing());
     ASSERT(m_textures.find(texture) == m_textures.end());
 
     texture->setManagerInternal(this);
     m_textures.add(texture);
 
 }
 
 void CCPrioritizedTextureManager::unregisterTexture(CCPrioritizedTexture* texture)
 {
+    ASSERT(CCProxy::isMainThread() || (CCProxy::isImplThread() && CCProxy::isMainThreadBlocked()));
     ASSERT(texture);
     ASSERT(m_textures.find(texture) != m_textures.end());
 
     returnBackingTexture(texture);
     texture->setManagerInternal(0);
     m_textures.remove(texture);
     texture->setAbovePriorityCutoff(false);
 }
 
-
 void CCPrioritizedTextureManager::returnBackingTexture(CCPrioritizedTexture* texture)
 {
+    ASSERT(CCProxy::isMainThread() || (CCProxy::isImplThread() && CCProxy::isMainThreadBlocked()));
     if (texture->backing()) {
         // Move the backing texture to the front for eviction/recycling and unlink it.
         m_backings.remove(texture->backing());
         m_backings.insertBefore(m_backings.begin(), texture->backing());
         texture->unlink();
     }
 }
 
 CCPrioritizedTexture::Backing* CCPrioritizedTextureManager::createBacking(IntSize size, GC3Denum format, CCResourceProvider* resourceProvider)
 {
+    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
     ASSERT(resourceProvider);
-
     CCResourceProvider::ResourceId resourceId = resourceProvider->createResource(m_pool, size, format, CCResourceProvider::TextureUsageAny);
     CCPrioritizedTexture::Backing* backing = new CCPrioritizedTexture::Backing(resourceId, size, format);
     m_memoryUseBytes += backing->bytes();
     // Put backing texture at the front for eviction, since it isn't in use yet.
     m_backings.insertBefore(m_backings.begin(), backing);
     return backing;
 }
 
 void CCPrioritizedTextureManager::destroyBacking(CCPrioritizedTexture::Backing* backing, CCResourceProvider* resourceProvider)
 {
     ASSERT(backing);
     ASSERT(!backing->owner() || !backing->owner()->isAbovePriorityCutoff());
     ASSERT(!backing->owner() || !backing->owner()->isSelfManaged());
     ASSERT(m_backings.find(backing) != m_backings.end());
 
     if (resourceProvider)
         resourceProvider->deleteResource(backing->id());
     if (backing->owner())
         backing->owner()->unlink();
     m_memoryUseBytes -= backing->bytes();
     m_backings.remove(backing);
 
     delete backing;
 }
 
 
 #if !ASSERT_DISABLED
 void CCPrioritizedTextureManager::assertInvariants()
 {
+    ASSERT(CCProxy::isMainThread());
+
     // If we hit any of these asserts, there is a bug in this class. To see
     // where the bug is, call this function at the beginning and end of
     // every public function.
 
     // Backings/textures must be doubly-linked and only to other backings/textures in this manager.
     for (BackingSet::iterator it = m_backings.begin(); it != m_backings.end(); ++it) {
         if ((*it)->owner()) {
             ASSERT(m_textures.find((*it)->owner()) != m_textures.end());
             ASSERT((*it)->owner()->backing() == (*it));
         }
@@ skipping 13 matching lines @@
         if ((*it)->owner() && (*it)->owner()->isAbovePriorityCutoff())
             reachedProtected = true;
         if (reachedProtected)
             ASSERT((*it)->owner() && (*it)->owner()->isAbovePriorityCutoff());
     }
 }
 #endif
 
 
 } // namespace WebCore