Switch to one single bitmap text blob cache allocation

src/core/SkDescriptor.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkDescriptor_DEFINED
@@ skipping 116 matching lines @@
     }
 
     // private so no one can create one except our factories
     SkDescriptor() {}
 };
 
 #include "SkScalerContext.h"
 
 class SkAutoDescriptor : SkNoncopyable {
 public:
-    SkAutoDescriptor(size_t size) {
-        if (size <= sizeof(fStorage)) {
+    SkAutoDescriptor() : fDesc(NULL), fHeapAllocSize(0) {}
+    SkAutoDescriptor(size_t size) : fDesc(NULL), fHeapAllocSize(0) { this->reset(size); }
+
+    ~SkAutoDescriptor() { this->free(); }
+
+    void reset(size_t size) {
+        if (this->isHeapAlloc()) {
+            if (size > fHeapAllocSize) {
+                this->free();
+                this->alloc(size);
+            }
+        } else if (size <= sizeof(fStorage)) {
             fDesc = (SkDescriptor*)(void*)fStorage;
         } else {
-            fDesc = SkDescriptor::Alloc(size);
+            SkASSERT(!fDesc);
+            this->alloc(size);
         }
     }
 
-    ~SkAutoDescriptor() {
-        if (fDesc != (SkDescriptor*)(void*)fStorage) {
+    SkDescriptor* getDesc() const { SkASSERT(fDesc); return fDesc; }
+private:
+    void alloc(size_t size) {
+        fDesc = SkDescriptor::Alloc(size);
+        fHeapAllocSize = size;
+    }
+    bool isHeapAlloc() const { return fDesc && fDesc != (SkDescriptor*)(void*)fStorage; }
+    void free() {
+        if (this->isHeapAlloc()) {
             SkDescriptor::Free(fDesc);
         }
     }
 
-    SkDescriptor* getDesc() const { return fDesc; }
-private:
     enum {
         kStorageSize =  sizeof(SkDescriptor)
                         + sizeof(SkDescriptor::Entry) + sizeof(SkScalerContext::Rec)    // for rec
                         + sizeof(SkDescriptor::Entry) + sizeof(void*)                   // for typeface
                         + 32   // slop for occational small extras
     };
     SkDescriptor*   fDesc;
     uint32_t        fStorage[(kStorageSize + 3) >> 2];
+    size_t          fHeapAllocSize;

[bsalomon, 2015/04/01 15:41:45]

Is this really worth the complexity? Seems much simpler to just have

reset(size_t size) {
    if (fDesc != (SkDescriptor*)(void*)fStorage) {
        SkDescriptor::Free(fDesc);
    }
    if (size <= sizeof(fStorage) {
        fDesc = (SkDescriptor*)(void*)fStorage;
    } else {
        fDesc = SkDescriptor::Alloc(size);
    }
}

and ~ can stay as it is. Do you expect to be reinit'ing these frequently where
the  size is larger than fStorage both before and after?

[joshualitt, 2015/04/01 16:54:23]

If I'm going to be reusing the blobs, which I basically can now that I just have
the large vertex pools, then I'll be reiniting the descriptor every time I
reuse.  Seems like a shame to free the alloc in that case, but its your call.

 };
 #define SkAutoDescriptor(...) SK_REQUIRE_LOCAL_VAR(SkAutoDescriptor)
 
 
 #endif