#include "SkPath.h"
#include "SkPathOps.h"
-#include <ResourceCache.h>
+#include <Caches.h>
#include <vector>
#include <map>
static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) {
SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- if (android::uirenderer::ResourceCache::hasInstance()) {
- android::uirenderer::ResourceCache::getInstance().destructor(obj);
- } else {
- delete obj;
+ // Purge entries from the HWUI path cache if this path's data is unique
+ if (obj->unique() && android::uirenderer::Caches::hasInstance()) {
+ android::uirenderer::Caches::getInstance().pathCache.removeDeferred(obj);
}
+ delete obj;
}
static jlong init1(JNIEnv* env, jobject clazz) {
resourceCache.decrementRefcountLocked(patchResources.itemAt(i));
}
- for (size_t i = 0; i < sourcePaths.size(); i++) {
- resourceCache.decrementRefcountLocked(sourcePaths.itemAt(i));
- }
-
resourceCache.unlock();
+ for (size_t i = 0; i < pathResources.size(); i++) {
+ const SkPath* path = pathResources.itemAt(i);
+ if (path->unique() && Caches::hasInstance()) {
+ Caches::getInstance().pathCache.removeDeferred(path);
+ }
+ delete path;
+ }
+
bitmapResources.clear();
patchResources.clear();
- sourcePaths.clear();
+ pathResources.clear();
paints.clear();
regions.clear();
- paths.clear();
}
size_t DisplayListData::addChild(DrawRenderNodeOp* op) {
int projectionReceiveIndex;
Vector<const SkBitmap*> bitmapResources;
+ Vector<const SkPath*> pathResources;
Vector<const Res_png_9patch*> patchResources;
std::vector<std::unique_ptr<const SkPaint>> paints;
std::vector<std::unique_ptr<const SkRegion>> regions;
- std::vector<std::unique_ptr<const SkPath>> paths;
- SortedVector<const SkPath*> sourcePaths;
Vector<Functor*> functors;
const Vector<Chunk>& getChunks() const {
inline const SkPath* refPath(const SkPath* path) {
if (!path) return nullptr;
- const SkPath* cachedPath = mPathMap.valueFor(path);
- if (cachedPath == nullptr || cachedPath->getGenerationID() != path->getGenerationID()) {
- SkPath* newPathCopy = new SkPath(*path);
- newPathCopy->setSourcePath(path);
- cachedPath = newPathCopy;
- std::unique_ptr<const SkPath> copy(newPathCopy);
- mDisplayListData->paths.push_back(std::move(copy));
-
- // replaceValueFor() performs an add if the entry doesn't exist
- mPathMap.replaceValueFor(path, cachedPath);
- }
- if (mDisplayListData->sourcePaths.indexOf(path) < 0) {
- mResourceCache.incrementRefcount(path);
- mDisplayListData->sourcePaths.add(path);
- }
+ // The points/verbs within the path are refcounted so this copy operation
+ // is inexpensive and maintains the generationID of the original path.
+ const SkPath* cachedPath = new SkPath(*path);
+ mDisplayListData->pathResources.add(cachedPath);
return cachedPath;
}
// Paths
///////////////////////////////////////////////////////////////////////////////
-void PathCache::remove(Vector<PathDescription>& pathsToRemove, const path_pair_t& pair) {
- LruCache<PathDescription, PathTexture*>::Iterator i(mCache);
-
- while (i.next()) {
- const PathDescription& key = i.key();
- if (key.type == kShapePath &&
- (key.shape.path.mPath == pair.getFirst() ||
- key.shape.path.mPath == pair.getSecond())) {
- pathsToRemove.push(key);
- }
- }
-}
-
-void PathCache::removeDeferred(SkPath* path) {
+void PathCache::removeDeferred(const SkPath* path) {
Mutex::Autolock l(mLock);
- mGarbage.push(path_pair_t(path, const_cast<SkPath*>(path->getSourcePath())));
+ mGarbage.push(path->getGenerationID());
}
void PathCache::clearGarbage() {
Mutex::Autolock l(mLock);
size_t count = mGarbage.size();
for (size_t i = 0; i < count; i++) {
- const path_pair_t& pair = mGarbage.itemAt(i);
- remove(pathsToRemove, pair);
- delete pair.getFirst();
+ const uint32_t generationID = mGarbage.itemAt(i);
+
+ LruCache<PathDescription, PathTexture*>::Iterator iter(mCache);
+ while (iter.next()) {
+ const PathDescription& key = iter.key();
+ if (key.type == kShapePath && key.shape.path.mGenerationID == generationID) {
+ pathsToRemove.push(key);
+ }
+ }
}
mGarbage.clear();
}
}
}
-/**
- * To properly handle path mutations at draw time we always make a copy
- * of paths objects when recording display lists. The source path points
- * to the path we originally copied the path from. This ensures we use
- * the original path as a cache key the first time a path is inserted
- * in the cache. The source path is also used to reclaim garbage when a
- * Dalvik Path object is collected.
- */
-static const SkPath* getSourcePath(const SkPath* path) {
- const SkPath* sourcePath = path->getSourcePath();
- if (sourcePath && sourcePath->getGenerationID() == path->getGenerationID()) {
- return const_cast<SkPath*>(sourcePath);
- }
- return path;
-}
-
PathTexture* PathCache::get(const SkPath* path, const SkPaint* paint) {
- path = getSourcePath(path);
-
PathDescription entry(kShapePath, paint);
- entry.shape.path.mPath = path;
+ entry.shape.path.mGenerationID = path->getGenerationID();
PathTexture* texture = mCache.get(entry);
texture = nullptr;
mCache.remove(entry);
}
- } else if (path->getGenerationID() != texture->generation) {
- // The size of the path might have changed so we first
- // remove the entry from the cache
- mCache.remove(entry);
- texture = addTexture(entry, path, paint);
}
}
return;
}
- path = getSourcePath(path);
-
PathDescription entry(kShapePath, paint);
- entry.shape.path.mPath = path;
+ entry.shape.path.mGenerationID = path->getGenerationID();
PathTexture* texture = mCache.get(entry);
bool generate = false;
if (!texture) {
generate = true;
- } else if (path->getGenerationID() != texture->generation) {
- mCache.remove(entry);
- generate = true;
}
if (generate) {
SkPathEffect* pathEffect;
union Shape {
struct Path {
- const SkPath* mPath;
+ uint32_t mGenerationID;
} path;
struct RoundRect {
float mWidth;
* Removes the specified path. This is meant to be called from threads
* that are not the EGL context thread.
*/
- void removeDeferred(SkPath* path);
+ ANDROID_API void removeDeferred(const SkPath* path);
/**
* Process deferred removals.
*/
float& left, float& top, float& offset, uint32_t& width, uint32_t& height);
private:
- typedef Pair<SkPath*, SkPath*> path_pair_t;
-
PathTexture* addTexture(const PathDescription& entry,
const SkPath *path, const SkPaint* paint);
PathTexture* addTexture(const PathDescription& entry, SkBitmap* bitmap);
}
/**
- * Removes an entry.
- * The pair must define first=path, second=sourcePath
- */
- void remove(Vector<PathDescription>& pathsToRemove, const path_pair_t& pair);
-
- /**
* Ensures there is enough space in the cache for a texture of the specified
* dimensions.
*/
delete future()->get();
}
- // copied, since input path not refcounted / guaranteed to survive for duration of task
- // TODO: avoid deep copy with refcounting
+ // copied, since input path not guaranteed to survive for duration of task
const SkPath path;
// copied, since input paint may not be immutable
sp<PathProcessor> mProcessor;
- Vector<path_pair_t> mGarbage;
+ Vector<uint32_t> mGarbage;
mutable Mutex mLock;
}; // class PathCache
incrementRefcountLocked(resource, resourceType);
}
-void ResourceCache::incrementRefcount(const SkPath* pathResource) {
- incrementRefcount((void*) pathResource, kPath);
-}
-
void ResourceCache::incrementRefcount(const Res_png_9patch* patchResource) {
incrementRefcount((void*) patchResource, kNinePatch);
}
decrementRefcountLocked(bitmapResource);
}
-void ResourceCache::decrementRefcount(const SkPath* pathResource) {
- decrementRefcount((void*) pathResource);
-}
-
void ResourceCache::decrementRefcount(const Res_png_9patch* patchResource) {
decrementRefcount((void*) patchResource);
}
}
}
-void ResourceCache::decrementRefcountLocked(const SkPath* pathResource) {
- decrementRefcountLocked((void*) pathResource);
-}
-
void ResourceCache::decrementRefcountLocked(const Res_png_9patch* patchResource) {
decrementRefcountLocked((void*) patchResource);
}
-void ResourceCache::destructor(SkPath* resource) {
- Mutex::Autolock _l(mLock);
- destructorLocked(resource);
-}
-
-void ResourceCache::destructorLocked(SkPath* resource) {
- ssize_t index = mCache->indexOfKey(resource);
- ResourceReference* ref = index >= 0 ? mCache->valueAt(index) : nullptr;
- if (ref == nullptr) {
- // If we're not tracking this resource, just delete it
- if (Caches::hasInstance()) {
- Caches::getInstance().pathCache.removeDeferred(resource);
- } else {
- delete resource;
- }
- return;
- }
- ref->destroyed = true;
- if (ref->refCount == 0) {
- deleteResourceReferenceLocked(resource, ref);
- }
-}
-
void ResourceCache::destructor(Res_png_9patch* resource) {
Mutex::Autolock _l(mLock);
destructorLocked(resource);
void ResourceCache::deleteResourceReferenceLocked(const void* resource, ResourceReference* ref) {
if (ref->destroyed) {
switch (ref->resourceType) {
- case kPath: {
- SkPath* path = (SkPath*) resource;
- if (Caches::hasInstance()) {
- Caches::getInstance().pathCache.removeDeferred(path);
- } else {
- delete path;
- }
- }
- break;
case kNinePatch: {
if (Caches::hasInstance()) {
Caches::getInstance().patchCache.removeDeferred((Res_png_9patch*) resource);
#include <cutils/compiler.h>
#include <SkBitmap.h>
-#include <SkPath.h>
#include <SkPixelRef.h>
#include <utils/KeyedVector.h>
*/
enum ResourceType {
kNinePatch,
- kPath
};
class ResourceReference {
*/
const SkBitmap* insert(const SkBitmap* resource);
- void incrementRefcount(const SkPath* resource);
void incrementRefcount(const Res_png_9patch* resource);
void decrementRefcount(const SkBitmap* resource);
- void decrementRefcount(const SkPath* resource);
void decrementRefcount(const Res_png_9patch* resource);
void decrementRefcountLocked(const SkBitmap* resource);
- void decrementRefcountLocked(const SkPath* resource);
void decrementRefcountLocked(const Res_png_9patch* resource);
- void destructor(SkPath* resource);
void destructor(Res_png_9patch* resource);
- void destructorLocked(SkPath* resource);
void destructorLocked(Res_png_9patch* resource);
private:
OSDN Git Service
