Use a lock to deal with concurrent access to the m_evictedBackings

cc/prioritized_resource_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 CC_PRIORITIZED_RESOURCE_MANAGER_H_
 #define CC_PRIORITIZED_RESOURCE_MANAGER_H_
 
 #include <list>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/synchronization/lock.h"
 #include "cc/cc_export.h"
 #include "cc/proxy.h"
 #include "cc/prioritized_resource.h"
 #include "cc/priority_calculator.h"
 #include "cc/resource.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/gfx/size.h"
 
 #if defined(COMPILER_GCC)
 namespace BASE_HASH_NAMESPACE {
@@ skipping 51 matching lines @@
     size_t memoryVisibleBytes() const;
     size_t memoryVisibleAndNearbyBytes() const;
 
     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. Returns true if resources are
     // indeed evicted as a result of this call.
     bool reduceMemoryOnImplThread(size_t limitBytes, int priorityCutoff, ResourceProvider*);
+
     // 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(BackingList& evictedBackings);
-    // Unlink the list of contents textures' backings from their owning textures on the main thread
-    // before updating layers.
-    void unlinkEvictedBackings(const BackingList& evictedBackings);
+    // may we allow drawing. After an eviction, this will not become true until
+    // unlinkAndClearEvictedBackings is called.
+    bool linkedEvictedBackingsExist();
+
+    // Unlink the list of contents textures' backings from their owning textures and delete the evicted
+    // backings' structures. This is called just before updating layers.
+    void unlinkAndClearEvictedBackings();

[jamesr, 2012/11/29 22:06:16]

You should document that this can be called from multiple threads

[piman, 2012/11/29 22:24:09]

Wait, this should only be called from the main thread, right?

[ccameron, 2012/11/29 22:25:35]

This one can only be called on the main thread -- I've added a comment to this
effect.

 
     bool requestLate(PrioritizedResource*);
 
     void reduceMemory(ResourceProvider*);
     void clearAllMemory(ResourceProvider*);
 
     void acquireBackingTextureIfNeeded(PrioritizedResource*, ResourceProvider*);
 
     void registerTexture(PrioritizedResource*);
     void unregisterTexture(PrioritizedResource*);
@@ skipping 47 matching lines @@
 
     PrioritizedResourceManager(int pool, const Proxy* proxy);
 
     bool evictBackingsToReduceMemory(size_t limitBytes,
                                      int priorityCutoff,
                                      EvictionPolicy,
                                      UnlinkPolicy,
                                      ResourceProvider*);
     PrioritizedResource::Backing* createBacking(gfx::Size, GLenum format, ResourceProvider*);
     void evictFirstBackingResource(ResourceProvider*);
-    void deleteAllEvictedBackings();
     void sortBackings();
 
     void assertInvariants();
 
     size_t m_maxMemoryLimitBytes;
     // The priority cutoff based on memory pressure. This is not a strict
     // cutoff -- requestLate allows textures with priority equal to this
     // cutoff to be allowed.
     int m_priorityCutoff;
     // The priority cutoff based on external memory policy. This is a strict
     // cutoff -- no textures with priority equal to this cutoff will be allowed.
     int m_externalPriorityCutoff;
     size_t m_memoryUseBytes;
     size_t m_memoryAboveCutoffBytes;
     size_t m_memoryAvailableBytes;
     int m_pool;
 
     typedef base::hash_set<PrioritizedResource*> TextureSet;
     typedef std::vector<PrioritizedResource*> TextureVector;
 
     const Proxy* m_proxy;
 
     TextureSet m_textures;
     // This list is always sorted in eviction order, with the exception the
     // newly-allocated or recycled textures at the very end of the tail that 
     // are not sorted by priority.
     BackingList m_backings;
     bool m_backingsTailNotSorted;
+
+    // The list of backings that have been evicted, but may still be linked
+    // to textures. This can be accessed concurrently by the main and impl
+    // threads, and may only be accessed while holding m_evictedBackingsLock.
     BackingList m_evictedBackings;
+    base::Lock m_evictedBackingsLock;
 
     TextureVector m_tempTextureVector;
 
     // Statistics about memory usage at priority cutoffs, computed at prioritizeTextures.
     size_t m_memoryVisibleBytes;
     size_t m_memoryVisibleAndNearbyBytes;
 
     // Statistics copied at the time of pushTexturePrioritiesToBackings.
     size_t m_memoryVisibleLastPushedBytes;
     size_t m_memoryVisibleAndNearbyLastPushedBytes;
 
     DISALLOW_COPY_AND_ASSIGN(PrioritizedResourceManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_PRIORITIZED_RESOURCE_MANAGER_H_