commit 42a741a2145c825b909327a520ebbb9b712e8fff
author Robert Phillips <robertphillips@google.com> Fri Oct 23 12:27:47 2020 -0400
committer Skia Commit-Bot <skia-commit-bot@chromium.org> Fri Oct 23 18:08:05 2020 +0000
tree 928953c7a404ce67ceb9682d3a818f2d926b959e
parent 7c64798b3d0c650b32f243a20f6a8e95e06f8c2c

Allow vertex data to be stored in the thread safe cache

Bug: 1108408
Change-Id: I4d51b9c837fad435c7a3e6823390b519b785631b
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/329363
Reviewed-by: Adlai Holler <adlai@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>

src/gpu/GrThreadSafeCache.cpp

diff --git a/src/gpu/GrThreadSafeCache.cpp b/src/gpu/GrThreadSafeCache.cpp
index a275075..23c65b2 100644
--- a/src/gpu/GrThreadSafeCache.cpp
+++ b/src/gpu/GrThreadSafeCache.cpp
@@ -13,6 +13,10 @@
 #include "src/gpu/GrRenderTargetContext.h"
 #include "src/gpu/GrResourceCache.h"
 
+GrThreadSafeCache::VertexData::~VertexData () {
+    this->reset();
+}
+
 GrThreadSafeCache::GrThreadSafeCache()
     : fFreeEntryList(nullptr) {
 }
@@ -95,15 +99,19 @@
     }
 }
 
+void GrThreadSafeCache::makeExistingEntryMRU(Entry* entry) {
+    SkASSERT(fUniquelyKeyedEntryList.isInList(entry));
+
+    entry->fLastAccess = GrStdSteadyClock::now();
+    fUniquelyKeyedEntryList.remove(entry);
+    fUniquelyKeyedEntryList.addToHead(entry);
+}
+
 std::tuple<GrSurfaceProxyView, sk_sp<SkData>> GrThreadSafeCache::internalFind(
                                                        const GrUniqueKey& key) {
     Entry* tmp = fUniquelyKeyedEntryMap.find(key);
     if (tmp) {
-        SkASSERT(fUniquelyKeyedEntryList.isInList(tmp));
-        // make the sought out entry the MRU
-        tmp->fLastAccess = GrStdSteadyClock::now();
-        fUniquelyKeyedEntryList.remove(tmp);
-        fUniquelyKeyedEntryList.addToHead(tmp);
+        this->makeExistingEntryMRU(tmp);
         return { tmp->view(), tmp->refCustomData() };
     }
 
@@ -139,13 +147,33 @@
         entry = fEntryAllocator.make<Entry>(key, view);
     }
 
-    // make 'entry' the MRU
+    return this->makeNewEntryMRU(entry);
+}
+
+GrThreadSafeCache::Entry* GrThreadSafeCache::makeNewEntryMRU(Entry* entry) {
     entry->fLastAccess = GrStdSteadyClock::now();
     fUniquelyKeyedEntryList.addToHead(entry);
     fUniquelyKeyedEntryMap.add(entry);
     return entry;
 }
 
+GrThreadSafeCache::Entry* GrThreadSafeCache::getEntry(const GrUniqueKey& key,
+                                                      sk_sp<VertexData> vertData) {
+    Entry* entry;
+
+    if (fFreeEntryList) {
+        entry = fFreeEntryList;
+        fFreeEntryList = entry->fNext;
+        entry->fNext = nullptr;
+
+        entry->set(key, std::move(vertData));
+    } else {
+        entry = fEntryAllocator.make<Entry>(key, std::move(vertData));
+    }
+
+    return this->makeNewEntryMRU(entry);
+}
+
 void GrThreadSafeCache::recycleEntry(Entry* dead) {
     SkASSERT(!dead->fPrev && !dead->fNext && !dead->fList);
 
@@ -211,6 +239,51 @@
     return this->internalAdd(key, v);
 }
 
+sk_sp<GrThreadSafeCache::VertexData> GrThreadSafeCache::MakeVertexData(const void* vertices,
+                                                                       int vertexCount,
+                                                                       size_t vertexSize) {
+    return sk_sp<VertexData>(new VertexData(vertices, vertexCount, vertexSize));
+}
+
+std::tuple<sk_sp<GrThreadSafeCache::VertexData>, sk_sp<SkData>> GrThreadSafeCache::internalFindVerts(
+                                                                         const GrUniqueKey& key) {
+    Entry* tmp = fUniquelyKeyedEntryMap.find(key);
+    if (tmp) {
+        this->makeExistingEntryMRU(tmp);
+        return { tmp->vertexData(), tmp->refCustomData() };
+    }
+
+    return {};
+}
+
+std::tuple<sk_sp<GrThreadSafeCache::VertexData>, sk_sp<SkData>> GrThreadSafeCache::findVertsWithData(
+                                                                          const GrUniqueKey& key) {
+    SkAutoSpinlock lock{fSpinLock};
+
+    return this->internalFindVerts(key);
+}
+
+std::tuple<sk_sp<GrThreadSafeCache::VertexData>, sk_sp<SkData>> GrThreadSafeCache::internalAddVerts(
+                                                                    const GrUniqueKey& key,
+                                                                    sk_sp<VertexData> vertData) {
+    Entry* tmp = fUniquelyKeyedEntryMap.find(key);
+    if (!tmp) {
+        tmp = this->getEntry(key, std::move(vertData));
+
+        SkASSERT(fUniquelyKeyedEntryMap.find(key));
+    }
+
+    return { tmp->vertexData(), tmp->refCustomData() };
+}
+
+std::tuple<sk_sp<GrThreadSafeCache::VertexData>, sk_sp<SkData>> GrThreadSafeCache::addVertsWithData(
+                                                                    const GrUniqueKey& key,
+                                                                    sk_sp<VertexData> vertData) {
+    SkAutoSpinlock lock{fSpinLock};
+
+    return this->internalAddVerts(key, std::move(vertData));
+}
+
 void GrThreadSafeCache::remove(const GrUniqueKey& key) {
     SkAutoSpinlock lock{fSpinLock};