Fix issue incremental upload can evict textures being drawn

cc/CCPrioritizedTextureManager.h

 // 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.
 
 #ifndef CCPrioritizedTextureManager_h
 #define CCPrioritizedTextureManager_h
 
 #include "base/basictypes.h"
 #include "CCPrioritizedTexture.h"
 #include "CCPriorityCalculator.h"
@@ skipping 39 matching lines @@
     size_t memoryAboveCutoffBytes() const { return m_memoryAboveCutoffBytes; }
     size_t memoryForSelfManagedTextures() const { return m_maxMemoryLimitBytes - m_memoryAvailableBytes; }
 
     void setMaxMemoryLimitBytes(size_t bytes) { m_maxMemoryLimitBytes = bytes; }
     size_t maxMemoryLimitBytes() const { return m_maxMemoryLimitBytes; }
 
     void prioritizeTextures();
     void clearPriorities();
 
     void reduceMemoryOnImplThread(size_t limitBytes, CCResourceProvider*);
-    bool evictedBackingsExist() const { return !m_evictedBackings.isEmpty(); }
+    bool linkedEvictedBackingsExist() const;

[epenner, 2012/10/09 17:25:04]

Nit: I was having trouble understanding what this function meant and 'linked' is
kind of an implementation detail. Maybe "backingsWereLost" or something that
that indicates an unexpected eviction has occurred?

[ccameron, 2012/10/09 21:03:56]

I added a comment saying that this returns true if "there exist any textures
that are linked to backings that have had their resources evicted", and some
more detail.

     void getEvictedBackings(BackingVector& evictedBackings);
     void unlinkEvictedBackings(const BackingVector& evictedBackings);
-    // Deletes all evicted backings, unlinking them from their owning textures if needed.
-    // Returns true if this function unlinked any backings from their owning texture while
-    // destroying them.
-    bool deleteEvictedBackings();
 
     bool requestLate(CCPrioritizedTexture*);
 
     void reduceMemory(CCResourceProvider*);
     void clearAllMemory(CCResourceProvider*);
 
     void acquireBackingTextureIfNeeded(CCPrioritizedTexture*, CCResourceProvider*);
 
     void registerTexture(CCPrioritizedTexture*);
     void unregisterTexture(CCPrioritizedTexture*);
     void returnBackingTexture(CCPrioritizedTexture*);
 
+    // Update all backings' priorities from their owning texture.
+    void pushTexturePrioritiesToBackings();
+
+    // Mark all textures' backings as being in the drawing impl tree.
+    void updateBackingsInDrawingImplTree();
+
 private:
     friend class CCPrioritizedTextureTest;
 
     enum EvictionPriorityPolicy {
         RespectManagerPriorityCutoff,
         DoNotRespectManagerPriorityCutoff,
     };
 
     // Compare textures. Highest priority first.
     static inline bool compareTextures(CCPrioritizedTexture* a, CCPrioritizedTexture* b)
     {
         if (a->requestPriority() == b->requestPriority())
             return a < b;
         return CCPriorityCalculator::priorityIsHigher(a->requestPriority(), b->requestPriority());
     }
     // Compare backings. Lowest priority first.
     static inline bool compareBackings(CCPrioritizedTexture::Backing* a, CCPrioritizedTexture::Backing* b)
     {
-        int priorityA = a->requestPriorityAtLastPriorityUpdate();
-        int priorityB = b->requestPriorityAtLastPriorityUpdate();
-        if (priorityA != priorityB)
-            return CCPriorityCalculator::priorityIsLower(priorityA, priorityB);
-        bool aboveCutoffA = a->wasAbovePriorityCutoffAtLastPriorityUpdate();
-        bool aboveCutoffB = b->wasAbovePriorityCutoffAtLastPriorityUpdate();
-        if (!aboveCutoffA && aboveCutoffB)
-            return true;
-        if (aboveCutoffA && !aboveCutoffB)
-            return false;
+        // Sort first by priority (note that backings that no longer have owners will 

[epenner, 2012/10/09 17:25:04]

If we make some backings recyclable by intentionally not pushing them into the
tree, then it looks like pushing the new priorities too early will mess with
their eviction order and disable that recycling (the recyclable textures will no
longer be at the beginning of this list). This is why I prefer to think of the
backings being in eviction order, as determined at sync-trees.

Anyway, it's not an issue as it stands since this doesn't keep recycling of
still-linked textures, but it makes me think we may need to revisit this again.

[ccameron, 2012/10/09 21:03:56]

I went ahead and put a "canBeRecycled" test first.

+        // always have the lowest priority)
+        if (a->requestPriorityAtLastPriorityUpdate() != b->requestPriorityAtLastPriorityUpdate())
+            return CCPriorityCalculator::priorityIsLower(a->requestPriorityAtLastPriorityUpdate(), b->requestPriorityAtLastPriorityUpdate());
+        // Then sort by being above or below the priority cutoff.
+        if (a->wasAbovePriorityCutoffAtLastPriorityUpdate() != b->wasAbovePriorityCutoffAtLastPriorityUpdate())
+            return (a->wasAbovePriorityCutoffAtLastPriorityUpdate() < b->wasAbovePriorityCutoffAtLastPriorityUpdate());
+        // Finally sort by being in the impl tree versus being completely unreferenced
+        if (a->inDrawingImplTree() != b->inDrawingImplTree())
+            return (a->inDrawingImplTree() < b->inDrawingImplTree());
         return a < b;
     }
 
     CCPrioritizedTextureManager(size_t maxMemoryLimitBytes, int maxTextureSize, int pool);
 
-    void updateBackingsPriorities();
     void evictBackingsToReduceMemory(size_t limitBytes, EvictionPriorityPolicy, CCResourceProvider*);
     CCPrioritizedTexture::Backing* createBacking(IntSize, GC3Denum format, CCResourceProvider*);
     void evictBackingResource(CCPrioritizedTexture::Backing*, CCResourceProvider*);
+    void deleteUnlinkedEvictedBackings();
+    void sortBackings();
 
 #if !ASSERT_DISABLED
     void assertInvariants();
 #endif
 
     size_t m_maxMemoryLimitBytes;
     unsigned m_priorityCutoff;
     size_t m_memoryUseBytes;
     size_t m_memoryAboveCutoffBytes;
     size_t m_memoryAvailableBytes;
     int m_pool;
 
     typedef HashSet<CCPrioritizedTexture*> TextureSet;
     typedef ListHashSet<CCPrioritizedTexture::Backing*> BackingSet;
     typedef Vector<CCPrioritizedTexture*> TextureVector;
 
     TextureSet m_textures;
     BackingSet m_backings;
     BackingVector m_evictedBackings;
 
     TextureVector m_tempTextureVector;
     BackingVector m_tempBackingVector;
 
-    // Set by the main thread when it adjust priorities in such a way that
-    // the m_backings array's view of priorities is now out of date.
-    bool m_needsUpdateBackingsPrioritites;
-
     DISALLOW_COPY_AND_ASSIGN(CCPrioritizedTextureManager);
 };
 
 }  // namespace cc
 
 #endif