Fix issue incremental upload can evict textures being drawn

cc/prioritized_texture_manager.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 "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 49 matching lines @@
     size_t memoryUseBytes() const { return m_memoryUseBytes; }
     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();
 
+    // Delete contents textures' backing resources until they use only bytesLimit bytes. This may
+    // be called on the impl thread while the main thread is running.
     void reduceMemoryOnImplThread(size_t limitBytes, CCResourceProvider*);
-    bool evictedBackingsExist() const { return !m_evictedBackings.isEmpty(); }
+    // Returns true if there exist any textures that are linked to backings that have had their
+    // resources evicted. Only when we commit a tree that has no textures linked to evicted backings
+    // may we allow drawing.
+    bool linkedEvictedBackingsExist() const;
+    // Retrieve the list of all contents textures' backings that have been evicted, to pass to the
+    // main thread to unlink them from their owning textures.
     void getEvictedBackings(BackingVector& evictedBackings);
+    // Unlink the list of contents textures' backings from their owning textures on the main thread
+    // before updating layers.
     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;
+        // Make textures that can be recycled appear first
+        if (a->canBeRecycled() != b->canBeRecycled())
+            return (a->canBeRecycled() > b->canBeRecycled());
+        // Then sort by being above or below the priority cutoff.
+        if (a->wasAbovePriorityCutoffAtLastPriorityUpdate() != b->wasAbovePriorityCutoffAtLastPriorityUpdate())
+            return (a->wasAbovePriorityCutoffAtLastPriorityUpdate() < b->wasAbovePriorityCutoffAtLastPriorityUpdate());
+        // Then sort by priority (note that backings that no longer have owners will
+        // always have the lowest priority)
+        if (a->requestPriorityAtLastPriorityUpdate() != b->requestPriorityAtLastPriorityUpdate())
+            return CCPriorityCalculator::priorityIsLower(a->requestPriorityAtLastPriorityUpdate(), b->requestPriorityAtLastPriorityUpdate());
+        // 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 base::hash_set<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