Tweak GrSmallPathAtlasMgr's cached path discovery methods

In an ideal world we wouldn't keep re-allocating the memory for the keys

Change-Id: I3b7954e131d483166d0bf0ce95510365869b134c
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/309123
Reviewed-by: Adlai Holler <[email protected]>
Commit-Queue: Robert Phillips <[email protected]>

Author: rphilli

src/gpu/ops/GrSmallPathAtlasMgr.cpp

@@ -41,7 +41,7 @@ bool GrSmallPathAtlasMgr::initAtlas(GrProxyProvider* proxyProvider, const GrCaps
     static constexpr size_t kPlotHeight = 256;
 
     const GrBackendFormat format = caps->getDefaultBackendFormat(GrColorType::kAlpha_8,
-                                                                    GrRenderable::kNo);
+                                                                 GrRenderable::kNo);
 
     GrDrawOpAtlasConfig atlasConfig(caps->maxTextureSize(), kMaxAtlasTextureBytes);
     SkISize size = atlasConfig.atlasDimensions(kA8_GrMaskFormat);
@@ -62,6 +62,7 @@ void GrSmallPathAtlasMgr::deleteCacheEntry(GrSmallPathShapeData* shapeData) {
 GrSmallPathShapeData* GrSmallPathAtlasMgr::findOrCreate(const GrSmallPathShapeDataKey& key) {
     auto shapeData = fShapeCache.find(key);
     if (!shapeData) {
+        // TODO: move the key into the ctor
         shapeData = new GrSmallPathShapeData(key);
         fShapeCache.add(shapeData);
         fShapeList.addToTail(shapeData);
@@ -75,6 +76,22 @@ GrSmallPathShapeData* GrSmallPathAtlasMgr::findOrCreate(const GrSmallPathShapeDa
     return shapeData;
 }
 
+GrSmallPathShapeData* GrSmallPathAtlasMgr::findOrCreate(const GrStyledShape& shape,
+                                                        int desiredDimension) {
+    GrSmallPathShapeDataKey key(shape, desiredDimension);
+
+    // TODO: move the key into 'findOrCreate'
+    return this->findOrCreate(key);
+}
+
+GrSmallPathShapeData* GrSmallPathAtlasMgr::findOrCreate(const GrStyledShape& shape,
+                                                        const SkMatrix& ctm) {
+    GrSmallPathShapeDataKey key(shape, ctm);
+
+    // TODO: move the key into 'findOrCreate'
+    return this->findOrCreate(key);
+}
+
 void GrSmallPathAtlasMgr::setUseToken(GrSmallPathShapeData* shapeData,
                                       GrDeferredUploadToken token) {
     fAtlas->setLastUseToken(shapeData->fAtlasLocator, token);

src/gpu/ops/GrSmallPathAtlasMgr.h

@@ -15,6 +15,7 @@
 
 class GrSmallPathShapeData;
 class GrSmallPathShapeDataKey;
+class GrStyledShape;
 
 /**
  * This class manages the small path renderer's atlas.
@@ -30,6 +31,9 @@ class GrSmallPathAtlasMgr : public GrOnFlushCallbackObject,
 
     GrDrawOpAtlas* atlas() { return fAtlas.get(); }
 
+    GrSmallPathShapeData* findOrCreate(const GrStyledShape&, int desiredDimension);
+    GrSmallPathShapeData* findOrCreate(const GrStyledShape&, const SkMatrix& ctm);
+
     const GrSurfaceProxyView* getViews(int* numActiveProxies) {
         *numActiveProxies = fAtlas->numActivePages();
         return fAtlas->getViews();
@@ -40,32 +44,34 @@ class GrSmallPathAtlasMgr : public GrOnFlushCallbackObject,
     // GrOnFlushCallbackObject overrides
     //
     // Note: because this class is associated with a path renderer we want it to be removed from
-    // the list of active OnFlushBackkbackObjects in an freeGpuResources call (i.e., we accept the
+    // the list of active OnFlushCallbackObjects in an freeGpuResources call (i.e., we accept the
     // default retainOnFreeGpuResources implementation).
     void preFlush(GrOnFlushResourceProvider* onFlushRP,
-                  const uint32_t* /*opsTaskIDs*/, int /*numOpsTaskIDs*/) override {
+                  const uint32_t* /* opsTaskIDs */,
+                  int /* numOpsTaskIDs */) override {
         if (fAtlas) {
             fAtlas->instantiate(onFlushRP);
         }
     }
 
     void postFlush(GrDeferredUploadToken startTokenForNextFlush,
-                   const uint32_t* /*opsTaskIDs*/, int /*numOpsTaskIDs*/) override {
+                   const uint32_t* /* opsTaskIDs */,
+                   int /* numOpsTaskIDs */) override {
         if (fAtlas) {
             fAtlas->compact(startTokenForNextFlush);
         }
     }
 
-    GrSmallPathShapeData* findOrCreate(const GrSmallPathShapeDataKey& key);
-
     void deleteCacheEntry(GrSmallPathShapeData*);
 
 private:
+    GrSmallPathShapeData* findOrCreate(const GrSmallPathShapeDataKey&);
+
+    void evict(GrDrawOpAtlas::PlotLocator) override;
+
     using ShapeCache = SkTDynamicHash<GrSmallPathShapeData, GrSmallPathShapeDataKey>;
     typedef SkTInternalLList<GrSmallPathShapeData> ShapeDataList;
 
-    void evict(GrDrawOpAtlas::PlotLocator plotLocator) override;
-
     std::unique_ptr<GrDrawOpAtlas> fAtlas;
     ShapeCache                     fShapeCache;
     ShapeDataList                  fShapeList;

src/gpu/ops/GrSmallPathRenderer.cpp

@@ -320,11 +320,12 @@ class GrSmallPathRenderer::SmallPathOp final : public GrMeshDrawOp {
                     }
                     mipSize = newMipSize;
                 }
+
                 SkScalar desiredDimension = std::min(mipSize, kMaxMIP);
+                int ceilDesiredDimension = SkScalarCeilToInt(desiredDimension);
 
                 // check to see if df path is cached
-                GrSmallPathShapeDataKey key(args.fShape, SkScalarCeilToInt(desiredDimension));
-                shapeData = fAtlasMgr->findOrCreate(key);
+                shapeData = fAtlasMgr->findOrCreate(args.fShape, ceilDesiredDimension);
                 if (!shapeData->fAtlasLocator.plotLocator().isValid()) {
                     SkScalar scale = desiredDimension / maxDim;
 
@@ -333,16 +334,15 @@ class GrSmallPathRenderer::SmallPathOp final : public GrMeshDrawOp {
                                                 fAtlasMgr->atlas(),
                                                 shapeData,
                                                 args.fShape,
-                                                SkScalarCeilToInt(desiredDimension),
+                                                ceilDesiredDimension,
                                                 scale)) {
                         fAtlasMgr->deleteCacheEntry(shapeData);
                         continue;
                     }
                 }
             } else {
                 // check to see if bitmap path is cached
-                GrSmallPathShapeDataKey key(args.fShape, args.fViewMatrix);
-                shapeData = fAtlasMgr->findOrCreate(key);
+                shapeData = fAtlasMgr->findOrCreate(args.fShape, args.fViewMatrix);
                 if (!shapeData->fAtlasLocator.plotLocator().isValid()) {
                     if (!this->addBMPathToAtlas(target,
                                                 &flushInfo,

src/gpu/ops/GrSmallPathShapeData.cpp

@@ -9,7 +9,7 @@
 
 #include "src/gpu/geometry/GrStyledShape.h"
 
-void GrSmallPathShapeDataKey::set(const GrStyledShape& shape, uint32_t dim) {
+GrSmallPathShapeDataKey::GrSmallPathShapeDataKey(const GrStyledShape& shape, uint32_t dim) {
     // Shapes' keys are for their pre-style geometry, but by now we shouldn't have any
     // relevant styling information.
     SkASSERT(shape.style().isSimpleFill());
@@ -20,7 +20,7 @@ void GrSmallPathShapeDataKey::set(const GrStyledShape& shape, uint32_t dim) {
     shape.writeUnstyledKey(&fKey[1]);
 }
 
-void GrSmallPathShapeDataKey::set(const GrStyledShape& shape, const SkMatrix& ctm) {
+GrSmallPathShapeDataKey::GrSmallPathShapeDataKey(const GrStyledShape& shape, const SkMatrix& ctm) {
     // Shapes' keys are for their pre-style geometry, but by now we shouldn't have any
     // relevant styling information.
     SkASSERT(shape.style().isSimpleFill());

src/gpu/ops/GrSmallPathShapeData.h

@@ -1,4 +1,3 @@
-
 /*
  * Copyright 2020 Google Inc.
  *
@@ -16,24 +15,19 @@ class GrStyledShape;
 
 class GrSmallPathShapeDataKey  {
 public:
-    GrSmallPathShapeDataKey () {}
-    GrSmallPathShapeDataKey (const GrSmallPathShapeDataKey & that) { *this = that; }
-    GrSmallPathShapeDataKey (const GrStyledShape& shape, uint32_t dim) { this->set(shape, dim); }
-    GrSmallPathShapeDataKey (const GrStyledShape& shape, const SkMatrix& ctm) {
-        this->set(shape, ctm);
-    }
-
-    GrSmallPathShapeDataKey & operator=(const GrSmallPathShapeDataKey & that) {
+    // TODO: add a move variant
+    GrSmallPathShapeDataKey(const GrSmallPathShapeDataKey& that) {
         fKey.reset(that.fKey.count());
         memcpy(fKey.get(), that.fKey.get(), fKey.count() * sizeof(uint32_t));
-        return *this;
     }
 
+    GrSmallPathShapeDataKey& operator=(const GrSmallPathShapeDataKey&) = delete;
+
     // for SDF paths
-    void set(const GrStyledShape&, uint32_t dim);
+    GrSmallPathShapeDataKey(const GrStyledShape&, uint32_t dim);
 
     // for bitmap paths
-    void set(const GrStyledShape&, const SkMatrix& ctm);
+    GrSmallPathShapeDataKey(const GrStyledShape&, const SkMatrix& ctm);
 
     bool operator==(const GrSmallPathShapeDataKey & that) const {
         return fKey.count() == that.fKey.count() &&
@@ -50,9 +44,9 @@ class GrSmallPathShapeDataKey  {
     SkAutoSTArray<24, uint32_t> fKey;
 };
 
-class GrSmallPathShapeData  {
+class GrSmallPathShapeData {
 public:
-    GrSmallPathShapeData(const GrSmallPathShapeDataKey &key) : fKey(key) {}
+    GrSmallPathShapeData(const GrSmallPathShapeDataKey& key) : fKey(key) {}
 
     const GrSmallPathShapeDataKey fKey;
     SkRect                        fBounds;