Convert SkWriter32 to use an SkTDArray for its internal storage.

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 253 matching lines @@
     typedef SkRefCnt INHERITED;
 };
 
 class SkFlatData {
 public:
     // Flatten obj into an SkFlatData with this index.  controller owns the SkFlatData*.
     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));
+        SkOrderedWriteBuffer buffer(storage, sizeof(storage));
 
         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));
 
@@ skipping 74 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 <typename T, typename Traits, int kScratchSizeGuess> friend class SkFlatDictionary;
+    template <typename T, typename Traits> friend class SkFlatDictionary;
 };
 
-template <typename T, typename Traits, int kScratchSizeGuess=0>
+template <typename T, typename Traits>
 class SkFlatDictionary {
-    static const size_t kWriteBufferGrowthBytes = 1024;
-
 public:
     explicit SkFlatDictionary(SkFlatController* controller)
     : fController(SkRef(controller))
-    , fScratchSize(0)
-    , fScratch(NULL)
-    , fWriteBuffer(kWriteBufferGrowthBytes)
     , fReady(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).
      */
     void reset() {
         fIndexedData.rewind();
     }
 
-    ~SkFlatDictionary() {
-        sk_free(fScratch);
-    }
-
     int count() const {
         SkASSERT(fHash.count() == fIndexedData.count());
         return fHash.count();
     }
 
     // For testing only.  Index is zero-based.
     const SkFlatData* operator[](int index) {
         return fIndexedData[index];
     }
 
@@ skipping 85 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);
     }
 
 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));
-    }
-
-    // We have to delay fWriteBuffer's initialization until its first use; fController might not
-    // be fully set up by the time we get it in the constructor. We also delay allocating fScratch
-    // to avoid unnecessary heap allocations, since we're paying the price of the conditional
-    // anyway.
+    // We have to delay fScratch's initialization until its first use; fController might not
+    // be fully set up by the time we get it in the constructor.
     void lazyInit() {
         if (fReady) {
             return;
         }
 
-        fScratchSize = kScratchSizeGuess;
-        fScratch = AllocScratch(fScratchSize);
-
         // Without a bitmap heap, we'll flatten bitmaps into paints.  That's never what you want.
         SkASSERT(fController->getBitmapHeap() != NULL);
-        fWriteBuffer.setBitmapHeap(fController->getBitmapHeap());
-        fWriteBuffer.setTypefaceRecorder(fController->getTypefaceSet());
-        fWriteBuffer.setNamedFactoryRecorder(fController->getNamedFactorySet());
-        fWriteBuffer.setFlags(fController->getWriteBufferFlags());
+        fScratch.setBitmapHeap(fController->getBitmapHeap());
+        fScratch.setTypefaceRecorder(fController->getTypefaceSet());
+        fScratch.setNamedFactoryRecorder(fController->getNamedFactorySet());
+        fScratch.setFlags(fController->getWriteBufferFlags());
         fReady = true;
     }
 
     // As findAndReturnFlat, but returns a mutable pointer for internal use.
     SkFlatData* findAndReturnMutableFlat(const T& element) {
         // Only valid until the next call to resetScratch().
         const SkFlatData& scratch = this->resetScratch(element, this->count()+1);
 
         SkFlatData* candidate = fHash.find(scratch);
         if (candidate != NULL) return candidate;
 
         SkFlatData* detached = this->detachScratch();
         fHash.add(detached);
         *fIndexedData.append() = detached;
         SkASSERT(fIndexedData.top()->index() == this->count());
         return detached;
     }
 
     // This reference is valid only until the next call to resetScratch() or detachScratch().
     const SkFlatData& resetScratch(const T& element, int index) {
         this->lazyInit();
 
-        // Flatten element into fWriteBuffer (using fScratch as storage).
-        fWriteBuffer.reset(fScratch->data(), fScratchSize);
-        Traits::flatten(fWriteBuffer, element);
-        const size_t bytesWritten = fWriteBuffer.bytesWritten();
+        // Layout of fScratch: [ SkFlatData header, 20 bytes ] [ data ..., 4-byte aligned ]
+        fScratch.reset();
+        fScratch.reserve(sizeof(SkFlatData));
+        Traits::flatten(fScratch, element);
+        const size_t dataSize = fScratch.bytesWritten() - sizeof(SkFlatData);
 
-        // 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());
-
-            // Carry on with this larger scratch to minimize the likelihood of future resizing.
-            sk_free(fScratch);
-            fScratchSize = bytesWritten;
-            fScratch = larger;
-        }
-
-        // The data is in fScratch now but we need to stamp its header.
-        fScratch->stampHeader(index, bytesWritten);
-        return *fScratch;
+        // Reinterpret data in fScratch as an SkFlatData.
+        SkFlatData* scratch = (SkFlatData*)fScratch.getWriter32()->contiguousArray();
+        SkASSERT(scratch != NULL);
+        scratch->stampHeader(index, dataSize);
+        return *scratch;
     }
 
     // This result is owned by fController and lives as long as it does (unless unalloc'd).
     SkFlatData* detachScratch() {
         // Allocate a new SkFlatData exactly big enough to hold our current scratch.
         // We use the controller for this allocation to extend the allocation's lifetime and allow
         // the controller to do whatever memory management it wants.
-        SkASSERT(fScratch != NULL);
-        const size_t paddedSize = SizeWithPadding(fScratch->flatSize());
-        SkFlatData* detached = (SkFlatData*)fController->allocThrow(paddedSize);
+        SkFlatData* detached = (SkFlatData*)fController->allocThrow(fScratch.bytesWritten());
 
         // Copy scratch into the new SkFlatData.
-        memcpy(detached, fScratch, paddedSize);
+        SkFlatData* scratch = (SkFlatData*)fScratch.getWriter32()->contiguousArray();
+        SkASSERT(scratch != NULL);
+        memcpy(detached, scratch, fScratch.bytesWritten());
 
         // We can now reuse fScratch, and detached will live until fController dies.
         return detached;
     }
 
     void unflatten(T* dst, const SkFlatData* element) const {
         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, lazily allocated, must be freed with sk_free.
-    SkOrderedWriteBuffer fWriteBuffer;
+    SkOrderedWriteBuffer fScratch;
     bool fReady;
 
     // For index -> SkFlatData.  0-based, while all indices in the API are 1-based.  Careful!
     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
 ///////////////////////////////////////////////////////////////////////////////
 
 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;
+typedef SkFlatDictionary<SkMatrix, SkMatrixTraits> SkMatrixDictionary;
 
 
 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;
+typedef SkFlatDictionary<SkPaint, SkPaintTraits> SkPaintDictionary;
 
 class SkChunkFlatController : public SkFlatController {
 public:
     SkChunkFlatController(size_t minSize)
     : fHeap(minSize)
     , fTypefaceSet(SkNEW(SkRefCntSet))
     , fLastAllocated(NULL) {
         this->setTypefaceSet(fTypefaceSet);
         this->setTypefacePlayback(&fTypefacePlayback);
     }
@@ skipping 18 matching lines @@
     }
 
 private:
     SkChunkAlloc               fHeap;
     SkAutoTUnref<SkRefCntSet>  fTypefaceSet;
     void*                      fLastAllocated;
     mutable SkTypefacePlayback fTypefacePlayback;
 };
 
 #endif