Function pointers -> templates in SkPictureFlat.

src/core/SkPictureFlat.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPictureFlat_DEFINED
 #define SkPictureFlat_DEFINED
 
@@ skipping 249 matching lines @@
     SkTypefacePlayback* fTypefacePlayback;
     SkNamedFactorySet*  fFactorySet;
     uint32_t            fWriteBufferFlags;
 
     typedef SkRefCnt INHERITED;
 };
 
 class SkFlatData {
 public:
     // Flatten obj into an SkFlatData with this index.  controller owns the SkFlatData*.
-    static SkFlatData* Create(SkFlatController* controller,
-                              const void* obj,
-                              int index,
-                              void (*flattenProc)(SkOrderedWriteBuffer&, const void*));
+    template <typename Traits, typename T>
+    static SkFlatData* Create(SkFlatController* controller, const T& obj, int index) {
+        // A buffer of 256 bytes should fit most paints, regions, and matrices.
+        uint32_t storage[64];
+        SkOrderedWriteBuffer buffer(256, storage, sizeof(storage));
 
-    // Unflatten this into result, using bitmapHeap and facePlayback for bitmaps and fonts if given.
-    void unflatten(void* result,
-                   void (*unflattenProc)(SkOrderedReadBuffer&, void*),
+        buffer.setBitmapHeap(controller->getBitmapHeap());
+        buffer.setTypefaceRecorder(controller->getTypefaceSet());
+        buffer.setNamedFactoryRecorder(controller->getNamedFactorySet());
+        buffer.setFlags(controller->getWriteBufferFlags());
+
+        Traits::flatten(buffer, obj);
+        uint32_t size = buffer.size();
+        SkASSERT(SkIsAlign4(size));
+
+        // Allocate enough memory to hold SkFlatData struct and the flat data itself.
+        size_t allocSize = sizeof(SkFlatData) + size;
+        SkFlatData* result = (SkFlatData*) controller->allocThrow(allocSize);
+
+        // Put the serialized contents into the data section of the new allocation.
+        buffer.writeToMemory(result->data());
+        // Stamp the index, size and checksum in the header.
+        result->stampHeader(index, size);
+        return result;
+    }
+
+    // Unflatten this into result, using bitmapHeap and facePlayback for bitmaps and fonts if given
+    template <typename Traits, typename T>
+    void unflatten(T* result,
                    SkBitmapHeap* bitmapHeap = NULL,
-                   SkTypefacePlayback* facePlayback = NULL) const;
+                   SkTypefacePlayback* facePlayback = NULL) const {
+        SkOrderedReadBuffer buffer(this->data(), fFlatSize);
+
+        if (bitmapHeap) {
+            buffer.setBitmapStorage(bitmapHeap);
+        }
+        if (facePlayback) {
+            facePlayback->setupBuffer(buffer);
+        }
+
+        Traits::unflatten(buffer, result);
+        SkASSERT(fFlatSize == (int32_t)buffer.offset());
+    }
 
     // Do these contain the same data?  Ignores index() and topBot().
     bool operator==(const SkFlatData& that) const {
         if (this->checksum() != that.checksum() || this->flatSize() != that.flatSize()) {
             return false;
         }
         return memcmp(this->data(), that.data(), this->flatSize()) == 0;
     }
 
     int index() const { return fIndex; }
@@ skipping 36 matching lines @@
         fTopBot[0] = SK_ScalarNaN;  // Mark as unwritten.
         fChecksum  = SkChecksum::Compute((uint32_t*)this->data(), size);
     }
 
     int fIndex;
     int32_t fFlatSize;
     uint32_t fChecksum;
     mutable SkScalar fTopBot[2];  // Cache of FontMetrics fTop, fBottom.  Starts as [NaN,?].
     // uint32_t flattenedData[] implicitly hangs off the end.
 
-    template <class T> friend class SkFlatDictionary;
+    template <typename T, typename Traits, int kScratchSizeGuess> friend class SkFlatDictionary;
 };
 
-template <class T>
+template <typename T, typename Traits, int kScratchSizeGuess=0>
 class SkFlatDictionary {
     static const size_t kWriteBufferGrowthBytes = 1024;
 
 public:
-    SkFlatDictionary(SkFlatController* controller, size_t scratchSizeGuess = 0)
-    : fFlattenProc(NULL)
-    , fUnflattenProc(NULL)
-    , fController(SkRef(controller))
-    , fScratchSize(scratchSizeGuess)
+    explicit SkFlatDictionary(SkFlatController* controller)
+    : fController(SkRef(controller))
+    , fScratchSize(kScratchSizeGuess)
     , fScratch(AllocScratch(fScratchSize))
     , fWriteBuffer(kWriteBufferGrowthBytes)
     , fWriteBufferReady(false) {
         this->reset();
     }
 
     /**
      * Clears the dictionary of all entries. However, it does NOT free the
      * memory that was allocated for each entry (that's owned by controller).
      */
@@ skipping 105 matching lines @@
     }
 
     /**
      * Find or insert a flattened version of element into the dictionary.
      * Caller does not take ownership of the result.  This will not return NULL.
      */
     const SkFlatData* findAndReturnFlat(const T& element) {
         return this->findAndReturnMutableFlat(element);
     }
 
-protected:
-    void (*fFlattenProc)(SkOrderedWriteBuffer&, const void*);
-    void (*fUnflattenProc)(SkOrderedReadBuffer&, void*);
-
 private:
     // Layout: [ SkFlatData header, 20 bytes ] [ data ..., 4-byte aligned ]
     static size_t SizeWithPadding(size_t flatDataSize) {
         SkASSERT(SkIsAlign4(flatDataSize));
         return sizeof(SkFlatData) + flatDataSize;
     }
 
     // Allocate a new scratch SkFlatData.  Must be sk_freed.
     static SkFlatData* AllocScratch(size_t scratchSize) {
         return (SkFlatData*) sk_malloc_throw(SizeWithPadding(scratchSize));
@@ skipping 28 matching lines @@
         fNextIndex++;
         return detached;
     }
 
     // This reference is valid only until the next call to resetScratch() or detachScratch().
     const SkFlatData& resetScratch(const T& element, int index) {
         this->lazyWriteBufferInit();
 
         // Flatten element into fWriteBuffer (using fScratch as storage).
         fWriteBuffer.reset(fScratch->data(), fScratchSize);
-        fFlattenProc(fWriteBuffer, &element);
+        Traits::flatten(fWriteBuffer, element);
         const size_t bytesWritten = fWriteBuffer.bytesWritten();
 
         // If all the flattened bytes fit into fScratch, we can skip a call to writeToMemory.
         if (!fWriteBuffer.wroteOnlyToStorage()) {
             SkASSERT(bytesWritten > fScratchSize);
             // It didn't all fit.  Copy into a larger replacement SkFlatData.
             // We can't just realloc because it might move the pointer and confuse writeToMemory.
             SkFlatData* larger = AllocScratch(bytesWritten);
             fWriteBuffer.writeToMemory(larger->data());
 
@@ skipping 17 matching lines @@
         SkFlatData* detached = (SkFlatData*)fController->allocThrow(paddedSize);
 
         // Copy scratch into the new SkFlatData.
         memcpy(detached, fScratch, paddedSize);
 
         // We can now reuse fScratch, and detached will live until fController dies.
         return detached;
     }
 
     void unflatten(T* dst, const SkFlatData* element) const {
-        element->unflatten(dst,
-                           fUnflattenProc,
-                           fController->getBitmapHeap(),
-                           fController->getTypefacePlayback());
+        element->unflatten<Traits>(dst,
+                                   fController->getBitmapHeap(),
+                                   fController->getTypefacePlayback());
     }
 
     // All SkFlatData* stored in fIndexedData and fHash are owned by the controller.
     SkAutoTUnref<SkFlatController> fController;
     size_t fScratchSize;  // How many bytes fScratch has allocated for data itself.
     SkFlatData* fScratch;  // Owned, must be freed with sk_free.
     SkOrderedWriteBuffer fWriteBuffer;
     bool fWriteBufferReady;
 
     // We map between SkFlatData and a 1-based integer index.
     int fNextIndex;
 
     // For index -> SkFlatData.  fIndexedData[0] is always NULL.
     SkTDArray<const SkFlatData*> fIndexedData;
 
     // For SkFlatData -> cached SkFlatData, which has index().
     SkTDynamicHash<SkFlatData, SkFlatData,
                    SkFlatData::Identity, SkFlatData::Hash, SkFlatData::Equal> fHash;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Some common dictionaries are defined here for both reference and convenience
 ///////////////////////////////////////////////////////////////////////////////
 
-template <class T>
-static void SkFlattenObjectProc(SkOrderedWriteBuffer& buffer, const void* obj) {
-    ((T*)obj)->flatten(buffer);
-}
+struct SkMatrixTraits {
+    static void flatten(SkOrderedWriteBuffer& buffer, const SkMatrix& matrix) {
+        buffer.getWriter32()->writeMatrix(matrix);
+    }
+    static void unflatten(SkOrderedReadBuffer& buffer, SkMatrix* matrix) {
+        buffer.getReader32()->readMatrix(matrix);
+    }
+};
+typedef SkFlatDictionary<SkMatrix, SkMatrixTraits, 36> SkMatrixDictionary;
 
-template <class T>
-static void SkUnflattenObjectProc(SkOrderedReadBuffer& buffer, void* obj) {
-    ((T*)obj)->unflatten(buffer);
-}
+
+struct SkRegionTraits {
+    static void flatten(SkOrderedWriteBuffer& buffer, const SkRegion& region) {
+        buffer.getWriter32()->writeRegion(region);
+    }
+    static void unflatten(SkOrderedReadBuffer& buffer, SkRegion* region) {
+        buffer.getReader32()->readRegion(region);
+    }
+};
+typedef SkFlatDictionary<SkRegion, SkRegionTraits> SkRegionDictionary;
+
+
+struct SkPaintTraits {
+    static void flatten(SkOrderedWriteBuffer& buffer, const SkPaint& paint) {
+        paint.flatten(buffer);
+    }
+    static void unflatten(SkOrderedReadBuffer& buffer, SkPaint* paint) {
+        paint->unflatten(buffer);
+    }
+};
+typedef SkFlatDictionary<SkPaint, SkPaintTraits, 512> SkPaintDictionary;
 
 class SkChunkFlatController : public SkFlatController {
 public:
     SkChunkFlatController(size_t minSize)
     : fHeap(minSize)
     , fTypefaceSet(SkNEW(SkRefCntSet))
     , fLastAllocated(NULL) {
         this->setTypefaceSet(fTypefaceSet);
         this->setTypefacePlayback(&fTypefacePlayback);
     }
@@ skipping 17 matching lines @@
         this->setBitmapHeap(heap);
     }
 
 private:
     SkChunkAlloc               fHeap;
     SkAutoTUnref<SkRefCntSet>  fTypefaceSet;
     void*                      fLastAllocated;
     mutable SkTypefacePlayback fTypefacePlayback;
 };
 
-class SkMatrixDictionary : public SkFlatDictionary<SkMatrix> {
- public:
-    // All matrices fit in 36 bytes.
-    SkMatrixDictionary(SkFlatController* controller)
-    : SkFlatDictionary<SkMatrix>(controller, 36) {
-        fFlattenProc = &flattenMatrix;
-        fUnflattenProc = &unflattenMatrix;
-    }
-
-    static void flattenMatrix(SkOrderedWriteBuffer& buffer, const void* obj) {
-        buffer.getWriter32()->writeMatrix(*(SkMatrix*)obj);
-    }
-
-    static void unflattenMatrix(SkOrderedReadBuffer& buffer, void* obj) {
-        buffer.getReader32()->readMatrix((SkMatrix*)obj);
-    }
-};
-
-class SkPaintDictionary : public SkFlatDictionary<SkPaint> {
- public:
-    // The largest paint across ~60 .skps was 500 bytes.
-    SkPaintDictionary(SkFlatController* controller)
-    : SkFlatDictionary<SkPaint>(controller, 512) {
-        fFlattenProc = &SkFlattenObjectProc<SkPaint>;
-        fUnflattenProc = &SkUnflattenObjectProc<SkPaint>;
-    }
-};
-
-class SkRegionDictionary : public SkFlatDictionary<SkRegion> {
- public:
-    SkRegionDictionary(SkFlatController* controller)
-    : SkFlatDictionary<SkRegion>(controller) {
-        fFlattenProc = &flattenRegion;
-        fUnflattenProc = &unflattenRegion;
-    }
-
-    static void flattenRegion(SkOrderedWriteBuffer& buffer, const void* obj) {
-        buffer.getWriter32()->writeRegion(*(SkRegion*)obj);
-    }
-
-    static void unflattenRegion(SkOrderedReadBuffer& buffer, void* obj) {
-        buffer.getReader32()->readRegion((SkRegion*)obj);
-    }
-};
-
 #endif