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, and is only ever called on the
+    // main thread.
+    void unlinkAndClearEvictedBackings();
 
     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;

[piman, 2012/11/29 22:34:11]

small nit: in many chrome classes, we tend to declare the lock right before the
fields it protects. That way it looks like on the calling code where you grab an
autolock before accessing the fields and has a nice symmetry.

[ccameron, 2012/11/30 00:02:17]

Good point. Done.

 
     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_