Simpler way to deal with the FBO multi-cache.

This change removes the need for the SortedList and instead just
add a generated id to each FBO stored in the cache. This is an
artificial way to store several FBOs with the same dimensions.

Change-Id: I9638364e9bdc0f2391261937a0c86096f20505bf

10 files changed, 33 insertions, 496 deletions

diff --git a/libs/hwui/Android.mk b/libs/hwui/Android.mk
index cbdbc3c..9146ba6 100644
--- a/libs/hwui/Android.mk
+++ b/libs/hwui/Android.mk
@@ -6,7 +6,6 @@ LOCAL_SRC_FILES:= \
 	Matrix.cpp \
 	OpenGLRenderer.cpp \
 	Program.cpp \
-	SortedList.cpp \
 	TextureCache.cpp
 
 LOCAL_C_INCLUDES += \
@@ -20,7 +19,7 @@ LOCAL_C_INCLUDES += \
 
 LOCAL_MODULE_CLASS := SHARED_LIBRARIES
 LOCAL_SHARED_LIBRARIES := libcutils libutils libGLESv2 libskia
-LOCAL_MODULE:= libhwui
+LOCAL_MODULE := libhwui
 LOCAL_PRELINK_MODULE := false
 
 include $(BUILD_SHARED_LIBRARY)
diff --git a/libs/hwui/GenerationCache.h b/libs/hwui/GenerationCache.h
index 5f64a35..5c1b5e1 100644
--- a/libs/hwui/GenerationCache.h
+++ b/libs/hwui/GenerationCache.h
@@ -20,68 +20,9 @@
 #include <utils/KeyedVector.h>
 #include <utils/RefBase.h>
 
-#include "SortedList.h"
-
 namespace android {
 namespace uirenderer {
 
-template<typename K, typename V>
-class GenerationCacheStorage {
-public:
-    virtual ~GenerationCacheStorage();
-
-    virtual size_t size() const = 0;
-    virtual void clear() = 0;
-    virtual ssize_t add(const K& key, const V& item) = 0;
-    virtual ssize_t indexOfKey(const K& key) const = 0;
-    virtual const V& valueAt(size_t index) const = 0;
-    virtual ssize_t removeItemsAt(size_t index, size_t count) = 0;
-}; // GenerationCacheStorage
-
-template<typename K, typename V>
-GenerationCacheStorage<K, V>::~GenerationCacheStorage() {
-}
-
-template<typename K, typename V>
-class KeyedVectorStorage: public GenerationCacheStorage<K, V> {
-public:
-    KeyedVectorStorage() { }
-    ~KeyedVectorStorage() { }
-
-    inline size_t size() const { return mStorage.size(); }
-    inline void clear() { mStorage.clear(); }
-    inline ssize_t add(const K& key, const V& value) { return mStorage.add(key, value); }
-    inline ssize_t indexOfKey(const K& key) const { return mStorage.indexOfKey(key); }
-    inline const V& valueAt(size_t index) const { return mStorage.valueAt(index); }
-    inline ssize_t removeItemsAt(size_t index, size_t count) {
-        return mStorage.removeItemsAt(index, count);
-    }
-private:
-    KeyedVector<K, V> mStorage;
-}; // class KeyedVectorStorage
-
-template<typename K, typename V>
-class SortedListStorage: public GenerationCacheStorage<K, V> {
-public:
-    SortedListStorage() { }
-    ~SortedListStorage() { }
-
-    inline size_t size() const { return mStorage.size(); }
-    inline void clear() { mStorage.clear(); }
-    inline ssize_t add(const K& key, const V& value) {
-        return mStorage.add(key_value_pair_t<K, V>(key, value));
-    }
-    inline ssize_t indexOfKey(const K& key) const {
-        return mStorage.indexOf(key_value_pair_t<K, V>(key));
-    }
-    inline const V& valueAt(size_t index) const { return mStorage.itemAt(index).value; }
-    inline ssize_t removeItemsAt(size_t index, size_t count) {
-        return mStorage.removeItemsAt(index, count);
-    }
-private:
-    SortedList<key_value_pair_t<K, V> > mStorage;
-}; // class SortedListStorage
-
 template<typename EntryKey, typename EntryValue>
 class OnEntryRemoved {
 public:
@@ -127,17 +68,13 @@ public:
 
     uint32_t size() const;
 
-protected:
-    virtual GenerationCacheStorage<K, sp<Entry<K, V> > >* createStorage() = 0;
-    GenerationCacheStorage<K, sp<Entry<K, V> > >* mCache;
-
-private:
     void addToCache(sp<Entry<K, V> > entry, K key, V value);
     void attachToCache(sp<Entry<K, V> > entry);
     void detachFromCache(sp<Entry<K, V> > entry);
 
     V removeAt(ssize_t index);
 
+    KeyedVector<K, sp<Entry<K, V> > > mCache;
     uint32_t mMaxCapacity;
 
     OnEntryRemoved<K, V>* mListener;
@@ -147,44 +84,17 @@ private:
 }; // class GenerationCache
 
 template<typename K, typename V>
-class GenerationSingleCache: public GenerationCache<K, V> {
-public:
-    GenerationSingleCache(uint32_t maxCapacity): GenerationCache<K, V>(maxCapacity) {
-        GenerationCache<K, V>::mCache = createStorage();
-    };
-    ~GenerationSingleCache() { }
-protected:
-    GenerationCacheStorage<K, sp<Entry<K, V> > >* createStorage() {
-        return new KeyedVectorStorage<K, sp<Entry<K, V> > >;
-    }
-}; // GenerationSingleCache
-
-template<typename K, typename V>
-class GenerationMultiCache: public GenerationCache<K, V> {
-public:
-    GenerationMultiCache(uint32_t maxCapacity): GenerationCache<K, V>(maxCapacity) {
-        GenerationCache<K, V>::mCache = createStorage();
-    };
-    ~GenerationMultiCache() { }
-protected:
-    GenerationCacheStorage<K, sp<Entry<K, V> > >* createStorage() {
-        return new SortedListStorage<K, sp<Entry<K, V> > >;
-    }
-}; // GenerationMultiCache
-
-template<typename K, typename V>
 GenerationCache<K, V>::GenerationCache(uint32_t maxCapacity): mMaxCapacity(maxCapacity), mListener(NULL) {
 };
 
 template<typename K, typename V>
 GenerationCache<K, V>::~GenerationCache() {
     clear();
-    delete mCache;
 };
 
 template<typename K, typename V>
 uint32_t GenerationCache<K, V>::size() const {
-    return mCache->size();
+    return mCache.size();
 }
 
 template<typename K, typename V>
@@ -195,11 +105,11 @@ void GenerationCache<K, V>::setOnEntryRemovedListener(OnEntryRemoved<K, V>* list
 template<typename K, typename V>
 void GenerationCache<K, V>::clear() {
     if (mListener) {
-        while (mCache->size() > 0) {
+        while (mCache.size() > 0) {
             removeOldest();
         }
     } else {
-        mCache->clear();
+        mCache.clear();
     }
     mYoungest.clear();
     mOldest.clear();
@@ -207,14 +117,14 @@ void GenerationCache<K, V>::clear() {
 
 template<typename K, typename V>
 bool GenerationCache<K, V>::contains(K key) const {
-    return mCache->indexOfKey(key) >= 0;
+    return mCache.indexOfKey(key) >= 0;
 }
 
 template<typename K, typename V>
 V GenerationCache<K, V>::get(K key) {
-    ssize_t index = mCache->indexOfKey(key);
+    ssize_t index = mCache.indexOfKey(key);
     if (index >= 0) {
-        sp<Entry<K, V> > entry = mCache->valueAt(index);
+        sp<Entry<K, V> > entry = mCache.valueAt(index);
         if (entry.get()) {
             detachFromCache(entry);
             attachToCache(entry);
@@ -227,13 +137,13 @@ V GenerationCache<K, V>::get(K key) {
 
 template<typename K, typename V>
 void GenerationCache<K, V>::put(K key, V value) {
-    if (mMaxCapacity != kUnlimitedCapacity && mCache->size() >= mMaxCapacity) {
+    if (mMaxCapacity != kUnlimitedCapacity && mCache.size() >= mMaxCapacity) {
         removeOldest();
     }
 
-    ssize_t index = mCache->indexOfKey(key);
+    ssize_t index = mCache.indexOfKey(key);
     if (index >= 0) {
-        sp<Entry<K, V> > entry = mCache->valueAt(index);
+        sp<Entry<K, V> > entry = mCache.valueAt(index);
         detachFromCache(entry);
         addToCache(entry, key, value);
     } else {
@@ -246,13 +156,13 @@ template<typename K, typename V>
 void GenerationCache<K, V>::addToCache(sp<Entry<K, V> > entry, K key, V value) {
     entry->key = key;
     entry->value = value;
-    entry->index = mCache->add(key, entry);
+    entry->index = mCache.add(key, entry);
     attachToCache(entry);
 }
 
 template<typename K, typename V>
 V GenerationCache<K, V>::remove(K key) {
-    ssize_t index = mCache->indexOfKey(key);
+    ssize_t index = mCache.indexOfKey(key);
     if (index >= 0) {
         return removeAt(index);
     }
@@ -262,11 +172,11 @@ V GenerationCache<K, V>::remove(K key) {
 
 template<typename K, typename V>
 V GenerationCache<K, V>::removeAt(ssize_t index) {
-    sp<Entry<K, V> > entry = mCache->valueAt(index);
+    sp<Entry<K, V> > entry = mCache.valueAt(index);
     if (mListener) {
         (*mListener)(entry->key, entry->value);
     }
-    mCache->removeItemsAt(index, 1);
+    mCache.removeItemsAt(index, 1);
     detachFromCache(entry);
 
     return entry->value;
diff --git a/libs/hwui/Layer.h b/libs/hwui/Layer.h
index 70d64ca..586a05e 100644
--- a/libs/hwui/Layer.h
+++ b/libs/hwui/Layer.h
@@ -30,14 +30,21 @@ namespace uirenderer {
  * Dimensions of a layer.
  */
 struct LayerSize {
-    LayerSize(): width(0), height(0) { }
-    LayerSize(const uint32_t width, const uint32_t height): width(width), height(height) { }
-    LayerSize(const LayerSize& size): width(size.width), height(size.height) { }
+    LayerSize(): width(0), height(0), id(0) { }
+    LayerSize(const uint32_t width, const uint32_t height): width(width), height(height), id(0) { }
+    LayerSize(const LayerSize& size): width(size.width), height(size.height), id(size.id) { }
 
     uint32_t width;
     uint32_t height;
 
+    // Incremental id used by the layer cache to store multiple
+    // LayerSize with the same dimensions
+    uint32_t id;
+
     bool operator<(const LayerSize& rhs) const {
+        if (id != 0 && rhs.id != 0) {
+            return id < rhs.id;
+        }
         if (width == rhs.width) {
             return height < rhs.height;
         }
diff --git a/libs/hwui/LayerCache.cpp b/libs/hwui/LayerCache.cpp
index 7d85e7b..882ad83 100644
--- a/libs/hwui/LayerCache.cpp
+++ b/libs/hwui/LayerCache.cpp
@@ -28,8 +28,8 @@ namespace uirenderer {
 ///////////////////////////////////////////////////////////////////////////////
 
 LayerCache::LayerCache(uint32_t maxByteSize):
-        mCache(GenerationMultiCache<LayerSize, Layer*>::kUnlimitedCapacity),
-        mSize(0), mMaxSize(maxByteSize) {
+        mCache(GenerationCache<LayerSize, Layer*>::kUnlimitedCapacity),
+        mIdGenerator(1), mSize(0), mMaxSize(maxByteSize) {
 }
 
 LayerCache::~LayerCache() {
@@ -101,6 +101,7 @@ bool LayerCache::put(LayerSize& layerSize, Layer* layer) {
             deleteLayer(oldest);
         }
 
+        layerSize.id = mIdGenerator++;
         mCache.put(layerSize, layer);
         mSize += size;
 
diff --git a/libs/hwui/LayerCache.h b/libs/hwui/LayerCache.h
index 2d339fa..519552d 100644
--- a/libs/hwui/LayerCache.h
+++ b/libs/hwui/LayerCache.h
@@ -66,7 +66,8 @@ public:
 private:
     void deleteLayer(Layer* layer);
 
-    GenerationMultiCache<LayerSize, Layer*> mCache;
+    GenerationCache<LayerSize, Layer*> mCache;
+    uint32_t mIdGenerator;
 
     uint32_t mSize;
     uint32_t mMaxSize;
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 0ade173..304af2e 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -35,7 +35,7 @@ namespace uirenderer {
 ///////////////////////////////////////////////////////////////////////////////
 
 // Debug
-#define DEBUG_LAYERS 0
+#define DEBUG_LAYERS 1
 
 // These properties are defined in mega-bytes
 #define PROPERTY_TEXTURE_CACHE_SIZE "ro.hwui.texture_cache_size"
diff --git a/libs/hwui/SortedList.cpp b/libs/hwui/SortedList.cpp
deleted file mode 100644
index 05adff5..0000000
--- a/libs/hwui/SortedList.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "SortedList.h"
-
-namespace android {
-namespace uirenderer {
-
-SortedListImpl::SortedListImpl(size_t itemSize, uint32_t flags) :
-    VectorImpl(itemSize, flags) {
-}
-
-SortedListImpl::SortedListImpl(const VectorImpl& rhs) :
-    VectorImpl(rhs) {
-}
-
-SortedListImpl::~SortedListImpl() {
-}
-
-SortedListImpl& SortedListImpl::operator =(const SortedListImpl& rhs) {
-    return static_cast<SortedListImpl&> (VectorImpl::operator =(
-            static_cast<const VectorImpl&> (rhs)));
-}
-
-ssize_t SortedListImpl::indexOf(const void* item) const {
-    return _indexOrderOf(item);
-}
-
-size_t SortedListImpl::orderOf(const void* item) const {
-    size_t o;
-    _indexOrderOf(item, &o);
-    return o;
-}
-
-ssize_t SortedListImpl::_indexOrderOf(const void* item, size_t* order) const {
-    // binary search
-    ssize_t err = NAME_NOT_FOUND;
-    ssize_t l = 0;
-    ssize_t h = size() - 1;
-    ssize_t mid;
-    const void* a = arrayImpl();
-    const size_t s = itemSize();
-    while (l <= h) {
-        mid = l + (h - l) / 2;
-        const void* const curr = reinterpret_cast<const char *> (a) + (mid * s);
-        const int c = do_compare(curr, item);
-        if (c == 0) {
-            err = l = mid;
-            break;
-        } else if (c < 0) {
-            l = mid + 1;
-        } else {
-            h = mid - 1;
-        }
-    }
-    if (order)
-        *order = l;
-    return err;
-}
-
-ssize_t SortedListImpl::add(const void* item) {
-    size_t order;
-    ssize_t index = _indexOrderOf(item, &order);
-    index = VectorImpl::insertAt(item, order, 1);
-    return index;
-}
-
-ssize_t SortedListImpl::merge(const VectorImpl& vector) {
-    // naive merge...
-    if (!vector.isEmpty()) {
-        const void* buffer = vector.arrayImpl();
-        const size_t is = itemSize();
-        size_t s = vector.size();
-        for (size_t i = 0; i < s; i++) {
-            ssize_t err = add(reinterpret_cast<const char*> (buffer) + i * is);
-            if (err < 0) {
-                return err;
-            }
-        }
-    }
-    return NO_ERROR;
-}
-
-ssize_t SortedListImpl::merge(const SortedListImpl& vector) {
-    // we've merging a sorted vector... nice!
-    ssize_t err = NO_ERROR;
-    if (!vector.isEmpty()) {
-        // first take care of the case where the vectors are sorted together
-        if (do_compare(vector.itemLocation(vector.size() - 1), arrayImpl()) <= 0) {
-            err = VectorImpl::insertVectorAt(static_cast<const VectorImpl&> (vector), 0);
-        } else if (do_compare(vector.arrayImpl(), itemLocation(size() - 1)) >= 0) {
-            err = VectorImpl::appendVector(static_cast<const VectorImpl&> (vector));
-        } else {
-            // this could be made a little better
-            err = merge(static_cast<const VectorImpl&> (vector));
-        }
-    }
-    return err;
-}
-
-ssize_t SortedListImpl::remove(const void* item) {
-    ssize_t i = indexOf(item);
-    if (i >= 0) {
-        VectorImpl::removeItemsAt(i, 1);
-    }
-    return i;
-}
-
-}
-; // namespace uirenderer
-}
-; // namespace android
-
diff --git a/libs/hwui/SortedList.h b/libs/hwui/SortedList.h
deleted file mode 100644
index 13cb64d..0000000
--- a/libs/hwui/SortedList.h
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_UI_SORTED_LIST_H
-#define ANDROID_UI_SORTED_LIST_H
-
-#include <utils/Vector.h>
-#include <utils/VectorImpl.h>
-
-namespace android {
-namespace uirenderer {
-
-class SortedListImpl: public VectorImpl {
-public:
-    SortedListImpl(size_t itemSize, uint32_t flags);
-    SortedListImpl(const VectorImpl& rhs);
-    virtual ~SortedListImpl();
-
-    SortedListImpl& operator =(const SortedListImpl& rhs);
-
-    ssize_t indexOf(const void* item) const;
-    size_t orderOf(const void* item) const;
-    ssize_t add(const void* item);
-    ssize_t merge(const VectorImpl& vector);
-    ssize_t merge(const SortedListImpl& vector);
-    ssize_t remove(const void* item);
-
-protected:
-    virtual int do_compare(const void* lhs, const void* rhs) const = 0;
-
-private:
-    ssize_t _indexOrderOf(const void* item, size_t* order = 0) const;
-
-    // these are made private, because they can't be used on a SortedList
-    // (they don't have an implementation either)
-    ssize_t add();
-    void pop();
-    void push();
-    void push(const void* item);
-    ssize_t insertVectorAt(const VectorImpl& vector, size_t index);
-    ssize_t appendVector(const VectorImpl& vector);
-    ssize_t insertArrayAt(const void* array, size_t index, size_t length);
-    ssize_t appendArray(const void* array, size_t length);
-    ssize_t insertAt(size_t where, size_t numItems = 1);
-    ssize_t insertAt(const void* item, size_t where, size_t numItems = 1);
-    ssize_t replaceAt(size_t index);
-    ssize_t replaceAt(const void* item, size_t index);
-}; // class SortedListImpl
-
-template<class TYPE>
-class SortedList: private SortedListImpl {
-public:
-    typedef TYPE value_type;
-
-    SortedList();
-    SortedList(const SortedList<TYPE>& rhs);
-    virtual ~SortedList();
-
-    const SortedList<TYPE>& operator =(const SortedList<TYPE>& rhs) const;
-    SortedList<TYPE>& operator =(const SortedList<TYPE>& rhs);
-
-    inline void clear() {
-        VectorImpl::clear();
-    }
-
-    inline size_t size() const {
-        return VectorImpl::size();
-    }
-
-    inline bool isEmpty() const {
-        return VectorImpl::isEmpty();
-    }
-
-    inline size_t capacity() const {
-        return VectorImpl::capacity();
-    }
-
-    inline ssize_t setCapacity(size_t size) {
-        return VectorImpl::setCapacity(size);
-    }
-
-    inline const TYPE* array() const;
-
-    TYPE* editArray();
-
-    ssize_t indexOf(const TYPE& item) const;
-
-    size_t orderOf(const TYPE& item) const;
-
-    inline const TYPE& operator [](size_t index) const;
-    inline const TYPE& itemAt(size_t index) const;
-    const TYPE& top() const;
-    const TYPE& mirrorItemAt(ssize_t index) const;
-
-    ssize_t add(const TYPE& item);
-
-    TYPE& editItemAt(size_t index) {
-        return *(static_cast<TYPE *> (VectorImpl::editItemLocation(index)));
-    }
-
-    ssize_t merge(const Vector<TYPE>& vector);
-    ssize_t merge(const SortedList<TYPE>& vector);
-
-    ssize_t remove(const TYPE&);
-
-    inline ssize_t removeItemsAt(size_t index, size_t count = 1);
-    inline ssize_t removeAt(size_t index) {
-        return removeItemsAt(index);
-    }
-
-protected:
-    virtual void do_construct(void* storage, size_t num) const;
-    virtual void do_destroy(void* storage, size_t num) const;
-    virtual void do_copy(void* dest, const void* from, size_t num) const;
-    virtual void do_splat(void* dest, const void* item, size_t num) const;
-    virtual void do_move_forward(void* dest, const void* from, size_t num) const;
-    virtual void
-    do_move_backward(void* dest, const void* from, size_t num) const;
-    virtual int do_compare(const void* lhs, const void* rhs) const;
-};
-
-template<class TYPE> inline SortedList<TYPE>::SortedList() :
-    SortedListImpl(sizeof(TYPE), ((traits<TYPE>::has_trivial_ctor ? HAS_TRIVIAL_CTOR : 0)
-            | (traits<TYPE>::has_trivial_dtor ? HAS_TRIVIAL_DTOR : 0)
-            | (traits<TYPE>::has_trivial_copy ? HAS_TRIVIAL_COPY : 0))) {
-}
-
-template<class TYPE> inline SortedList<TYPE>::SortedList(const SortedList<TYPE>& rhs) :
-    SortedListImpl(rhs) {
-}
-
-template<class TYPE> inline SortedList<TYPE>::~SortedList() {
-    finish_vector();
-}
-
-template<class TYPE> inline SortedList<TYPE>& SortedList<TYPE>::operator =(
-        const SortedList<TYPE>& rhs) {
-    SortedListImpl::operator =(rhs);
-    return *this;
-}
-
-template<class TYPE> inline const SortedList<TYPE>& SortedList<TYPE>::operator =(const SortedList<
-        TYPE>& rhs) const {
-    SortedListImpl::operator =(rhs);
-    return *this;
-}
-
-template<class TYPE> inline const TYPE* SortedList<TYPE>::array() const {
-    return static_cast<const TYPE *> (arrayImpl());
-}
-
-template<class TYPE> inline TYPE* SortedList<TYPE>::editArray() {
-    return static_cast<TYPE *> (editArrayImpl());
-}
-
-template<class TYPE> inline const TYPE& SortedList<TYPE>::operator[](size_t index) const {
-    assert( index<size() );
-    return *(array() + index);
-}
-
-template<class TYPE> inline const TYPE& SortedList<TYPE>::itemAt(size_t index) const {
-    return operator[](index);
-}
-
-template<class TYPE> inline const TYPE& SortedList<TYPE>::mirrorItemAt(ssize_t index) const {
-    assert( (index>0 ? index : -index)<size() );
-    return *(array() + ((index < 0) ? (size() - index) : index));
-}
-
-template<class TYPE> inline const TYPE& SortedList<TYPE>::top() const {
-    return *(array() + size() - 1);
-}
-
-template<class TYPE> inline ssize_t SortedList<TYPE>::add(const TYPE& item) {
-    return SortedListImpl::add(&item);
-}
-
-template<class TYPE> inline ssize_t SortedList<TYPE>::indexOf(const TYPE& item) const {
-    return SortedListImpl::indexOf(&item);
-}
-
-template<class TYPE> inline size_t SortedList<TYPE>::orderOf(const TYPE& item) const {
-    return SortedListImpl::orderOf(&item);
-}
-
-template<class TYPE> inline ssize_t SortedList<TYPE>::merge(const Vector<TYPE>& vector) {
-    return SortedListImpl::merge(reinterpret_cast<const VectorImpl&> (vector));
-}
-
-template<class TYPE> inline ssize_t SortedList<TYPE>::merge(const SortedList<TYPE>& vector) {
-    return SortedListImpl::merge(reinterpret_cast<const SortedListImpl&> (vector));
-}
-
-template<class TYPE> inline ssize_t SortedList<TYPE>::remove(const TYPE& item) {
-    return SortedListImpl::remove(&item);
-}
-
-template<class TYPE> inline ssize_t SortedList<TYPE>::removeItemsAt(size_t index, size_t count) {
-    return VectorImpl::removeItemsAt(index, count);
-}
-
-template<class TYPE>
-void SortedList<TYPE>::do_construct(void* storage, size_t num) const {
-    construct_type(reinterpret_cast<TYPE*> (storage), num);
-}
-
-template<class TYPE>
-void SortedList<TYPE>::do_destroy(void* storage, size_t num) const {
-    destroy_type(reinterpret_cast<TYPE*> (storage), num);
-}
-
-template<class TYPE>
-void SortedList<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
-    copy_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (from), num);
-}
-
-template<class TYPE>
-void SortedList<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
-    splat_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (item), num);
-}
-
-template<class TYPE>
-void SortedList<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
-    move_forward_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (from), num);
-}
-
-template<class TYPE>
-void SortedList<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
-    move_backward_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (from), num);
-}
-
-template<class TYPE>
-int SortedList<TYPE>::do_compare(const void* lhs, const void* rhs) const {
-    return compare_type(*reinterpret_cast<const TYPE*> (lhs), *reinterpret_cast<const TYPE*> (rhs));
-}
-
-}
-; // namespace uirenderer
-}
-; // namespace android
-
-#endif // ANDROID_UI_SORTED_LIST_H
diff --git a/libs/hwui/TextureCache.cpp b/libs/hwui/TextureCache.cpp
index 460284e..612f04e 100644
--- a/libs/hwui/TextureCache.cpp
+++ b/libs/hwui/TextureCache.cpp
@@ -28,7 +28,7 @@ namespace uirenderer {
 ///////////////////////////////////////////////////////////////////////////////
 
 TextureCache::TextureCache(uint32_t maxByteSize):
-        mCache(GenerationSingleCache<SkBitmap*, Texture*>::kUnlimitedCapacity),
+        mCache(GenerationCache<SkBitmap*, Texture*>::kUnlimitedCapacity),
         mSize(0), mMaxSize(maxByteSize) {
     mCache.setOnEntryRemovedListener(this);
 }
diff --git a/libs/hwui/TextureCache.h b/libs/hwui/TextureCache.h
index a620876..bed1191 100644
--- a/libs/hwui/TextureCache.h
+++ b/libs/hwui/TextureCache.h
@@ -78,7 +78,7 @@ private:
      */
     void generateTexture(SkBitmap* bitmap, Texture* texture, bool regenerate = false);
 
-    GenerationSingleCache<SkBitmap*, Texture*> mCache;
+    GenerationCache<SkBitmap*, Texture*> mCache;
 
     uint32_t mSize;
     uint32_t mMaxSize;