Start from scratch on a faster SkFlatDictionary.

src/core/SkOrderedWriteBuffer.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 SkOrderedWriteBuffer_DEFINED
 #define SkOrderedWriteBuffer_DEFINED
 
 #include "SkFlattenableBuffers.h"
 
 #include "SkRefCnt.h"
 #include "SkBitmapHeap.h"
 #include "SkPath.h"
 #include "SkPicture.h"
 #include "SkWriter32.h"
 
 class SkBitmap;
 class SkFlattenable;
 class SkFactorySet;
 class SkNamedFactorySet;
 class SkRefCntSet;
 
 class SkOrderedWriteBuffer : public SkFlattenableWriteBuffer {
 public:
     SkOrderedWriteBuffer(size_t minSize);
-    SkOrderedWriteBuffer(size_t minSize, void* initialStorage,
-                         size_t storageSize);
+    SkOrderedWriteBuffer(size_t minSize, void* initialStorage, size_t storageSize);
     virtual ~SkOrderedWriteBuffer();
 
     virtual bool isOrderedBinaryBuffer() SK_OVERRIDE { return true; }
     virtual SkOrderedWriteBuffer* getOrderedBinaryBuffer() SK_OVERRIDE { return this; }
 
     SkWriter32* getWriter32() { return &fWriter; }
+    void reset(void* storage, size_t storageSize) { fWriter.reset(storage, storageSize); }
+
+    // Returns true if we've written only into the storage passed into constructor or reset.
+    // (You may be able to use this to avoid a call to writeToMemory.)
+    bool wroteOnlyToStorage() const { return fWriter.wroteOnlyToStorage(); }
 
     void writeToMemory(void* dst) { fWriter.flatten(dst); }
     uint32_t* reserve(size_t size) { return fWriter.reserve(size); }
-    uint32_t size() { return fWriter.size(); }
+
+    uint32_t bytesWritten() const { return fWriter.bytesWritten(); }
+    // Deprecated.  Please call bytesWritten instead.  TODO(mtklein): clean up
+    uint32_t size() const { return this->bytesWritten(); }
 
     virtual void writeByteArray(const void* data, size_t size) SK_OVERRIDE;
     virtual void writeBool(bool value) SK_OVERRIDE;
     virtual void writeFixed(SkFixed value) SK_OVERRIDE;
     virtual void writeScalar(SkScalar value) SK_OVERRIDE;
     virtual void writeScalarArray(const SkScalar* value, uint32_t count) SK_OVERRIDE;
     virtual void writeInt(int32_t value) SK_OVERRIDE;
     virtual void writeIntArray(const int32_t* value, uint32_t count) SK_OVERRIDE;
     virtual void writeUInt(uint32_t value) SK_OVERRIDE;
     virtual void write32(int32_t value) SK_OVERRIDE;
@@ skipping 50 matching lines @@
 
     SkBitmapHeap* fBitmapHeap;
     SkRefCntSet* fTFSet;
 
     SkPicture::EncodeBitmap fBitmapEncoder;
 
     typedef SkFlattenableWriteBuffer INHERITED;
 };
 
 #endif // SkOrderedWriteBuffer_DEFINED