Prototype code that turns any/every flattenable into JSON

include/core/SkWriteBuffer.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 SkWriteBuffer_DEFINED
 #define SkWriteBuffer_DEFINED
 
 #include "SkData.h"
 #include "SkImage.h"
 #include "SkPath.h"
 #include "SkPicture.h"
 #include "SkPixelSerializer.h"
 #include "SkRefCnt.h"
 #include "SkWriter32.h"
 #include "../private/SkTHash.h"
 
 class SkBitmap;
 class SkBitmapHeap;
 class SkFactorySet;
 class SkFlattenable;
 class SkRefCntSet;
 
 class SkWriteBuffer {
 public:
+    SkWriteBuffer() {}
+    virtual ~SkWriteBuffer() {}
+
+    virtual bool isCrossProcess() const = 0;
+
+    // This is the only really leaky abstraction in this interface:
+    virtual uint32_t* reserve(size_t size) = 0;

[Brian Osman, 2016/04/28 14:22:32]

All of the other "binary" parts (and implementation details) of the interface
are only used in places where we can be sure that we have an
SkBinaryWriteBuffer. This function is used in exactly one place, when flattening
an SkPaint. I've arranged things so we should never encounter it in the JSON
implementation, but also made the JSON version safe. FYI.

+
+    virtual void writeByteArray(const void* data, size_t size) = 0;
+    virtual void writeDataAsByteArray(SkData* data) = 0;
+    virtual void writeBool(bool value) = 0;;
+    virtual void writeScalar(SkScalar value) = 0;
+    virtual void writeScalarArray(const SkScalar* value, uint32_t count) = 0;
+    virtual void writeInt(int32_t value) = 0;
+    virtual void writeIntArray(const int32_t* value, uint32_t count) = 0;
+    virtual void writeUInt(uint32_t value) = 0;
+    virtual void write32(int32_t value) = 0;
+    virtual void writeString(const char* value) = 0;
+    virtual void writeEncodedString(const void* value, size_t byteLength,
+                                    SkPaint::TextEncoding encoding) = 0;
+    virtual void writeFunctionPtr(void* ptr) = 0;
+
+    virtual void writeFlattenable(const SkFlattenable* flattenable) = 0;
+    virtual void writeColor(const SkColor& color) = 0;
+    virtual void writeColorArray(const SkColor* color, uint32_t count) = 0;
+    virtual void writePoint(const SkPoint& point) = 0;
+    virtual void writePointArray(const SkPoint* point, uint32_t count) = 0;
+    virtual void writeMatrix(const SkMatrix& matrix) = 0;
+    virtual void writeIRect(const SkIRect& rect) = 0;
+    virtual void writeRect(const SkRect& rect) = 0;
+    virtual void writeRegion(const SkRegion& region) = 0;
+    virtual void writePath(const SkPath& path) = 0;
+    virtual size_t writeStream(SkStream* stream, size_t length) = 0;
+    virtual void writeBitmap(const SkBitmap& bitmap) = 0;
+    virtual void writeImage(const SkImage*) = 0;
+    virtual void writeTypeface(SkTypeface* typeface) = 0;
+    virtual void writePaint(const SkPaint& paint) = 0;
+};
+
+/**
+ * Concrete implementation that serializes to a flat binary blob.
+ */
+class SkBinaryWriteBuffer : public SkWriteBuffer {
+public:
     enum Flags {
-        kCrossProcess_Flag  = 1 << 0,
+        kCrossProcess_Flag = 1 << 0,
     };
 
-    SkWriteBuffer(uint32_t flags = 0);
-    SkWriteBuffer(void* initialStorage, size_t storageSize, uint32_t flags = 0);
-    ~SkWriteBuffer();
+    SkBinaryWriteBuffer(uint32_t flags = 0);
+    SkBinaryWriteBuffer(void* initialStorage, size_t storageSize, uint32_t flags = 0);
+    ~SkBinaryWriteBuffer();
 
-    bool isCrossProcess() const {
+    bool isCrossProcess() const override {
         return SkToBool(fFlags & kCrossProcess_Flag);
     }
 
     SkWriter32* getWriter32() { return &fWriter; }
     void reset(void* storage = NULL, size_t storageSize = 0) {
         fWriter.reset(storage, storageSize);
     }
 
-    uint32_t* reserve(size_t size) { return fWriter.reserve(size); }
+    uint32_t* reserve(size_t size) override { return fWriter.reserve(size); }
 
     size_t bytesWritten() const { return fWriter.bytesWritten(); }
 
-    void writeByteArray(const void* data, size_t size);
-    void writeDataAsByteArray(SkData* data) { this->writeByteArray(data->data(), data->size()); }
-    void writeBool(bool value);
-    void writeScalar(SkScalar value);
-    void writeScalarArray(const SkScalar* value, uint32_t count);
-    void writeInt(int32_t value);
-    void writeIntArray(const int32_t* value, uint32_t count);
-    void writeUInt(uint32_t value);
-    void write32(int32_t value);
-    void writeString(const char* value);
-    void writeEncodedString(const void* value, size_t byteLength, SkPaint::TextEncoding encoding);
-    void writeFunctionPtr(void* ptr) { fWriter.writePtr(ptr); }
+    void writeByteArray(const void* data, size_t size) override;
+    void writeDataAsByteArray(SkData* data) override {
+        this->writeByteArray(data->data(), data->size());
+    }
+    void writeBool(bool value) override;
+    void writeScalar(SkScalar value) override;
+    void writeScalarArray(const SkScalar* value, uint32_t count) override;
+    void writeInt(int32_t value) override;
+    void writeIntArray(const int32_t* value, uint32_t count) override;
+    void writeUInt(uint32_t value) override;
+    void write32(int32_t value) override;
+    void writeString(const char* value) override;
+    void writeEncodedString(const void* value, size_t byteLength,
+                            SkPaint::TextEncoding encoding) override;
+    void writeFunctionPtr(void* ptr) override { fWriter.writePtr(ptr); }
 
-    void writeFlattenable(const SkFlattenable* flattenable);
-    void writeColor(const SkColor& color);
-    void writeColorArray(const SkColor* color, uint32_t count);
-    void writePoint(const SkPoint& point);
-    void writePointArray(const SkPoint* point, uint32_t count);
-    void writeMatrix(const SkMatrix& matrix);
-    void writeIRect(const SkIRect& rect);
-    void writeRect(const SkRect& rect);
-    void writeRegion(const SkRegion& region);
-    void writePath(const SkPath& path);
-    size_t writeStream(SkStream* stream, size_t length);
-    void writeBitmap(const SkBitmap& bitmap);
-    void writeImage(const SkImage*);
-    void writeTypeface(SkTypeface* typeface);
-    void writePaint(const SkPaint& paint) { paint.flatten(*this); }
+    void writeFlattenable(const SkFlattenable* flattenable) override;
+    void writeColor(const SkColor& color) override;
+    void writeColorArray(const SkColor* color, uint32_t count) override;
+    void writePoint(const SkPoint& point) override;
+    void writePointArray(const SkPoint* point, uint32_t count) override;
+    void writeMatrix(const SkMatrix& matrix) override;
+    void writeIRect(const SkIRect& rect) override;
+    void writeRect(const SkRect& rect) override;
+    void writeRegion(const SkRegion& region) override;
+    void writePath(const SkPath& path) override;
+    size_t writeStream(SkStream* stream, size_t length) override;
+    void writeBitmap(const SkBitmap& bitmap) override;
+    void writeImage(const SkImage*) override;
+    void writeTypeface(SkTypeface* typeface) override;
+    void writePaint(const SkPaint& paint) override { paint.flatten(*this); }
 
     bool writeToStream(SkWStream*);
     void writeToMemory(void* dst) { fWriter.flatten(dst); }
 
     SkFactorySet* setFactoryRecorder(SkFactorySet*);
-
-    SkRefCntSet* getTypefaceRecorder() const { return fTFSet; }
     SkRefCntSet* setTypefaceRecorder(SkRefCntSet*);
 
     /**
-     * Set an SkBitmapHeap to store bitmaps rather than flattening.
-     *
-     * Incompatible with an SkPixelSerializer. If an SkPixelSerializer is set,
-     * setting an SkBitmapHeap will set the SkPixelSerializer to NULL in release
-     * and crash in debug.
-     */
+    * Set an SkBitmapHeap to store bitmaps rather than flattening.
+    *
+    * Incompatible with an SkPixelSerializer. If an SkPixelSerializer is set,
+    * setting an SkBitmapHeap will set the SkPixelSerializer to NULL in release
+    * and crash in debug.
+    */
     void setBitmapHeap(SkBitmapHeap*);
 
     /**
-     * Set an SkPixelSerializer to store an encoded representation of pixels,
-     * e.g. SkBitmaps.
-     *
-     * Calls ref() on the serializer.
-     *
-     * TODO: Encode SkImage pixels as well.
-     *
-     * Incompatible with the SkBitmapHeap. If an encoder is set fBitmapHeap will
-     * be set to NULL in release and crash in debug.
-     */
+    * Set an SkPixelSerializer to store an encoded representation of pixels,
+    * e.g. SkBitmaps.
+    *
+    * Calls ref() on the serializer.
+    *
+    * TODO: Encode SkImage pixels as well.
+    *
+    * Incompatible with the SkBitmapHeap. If an encoder is set fBitmapHeap will
+    * be set to NULL in release and crash in debug.
+    */
     void setPixelSerializer(SkPixelSerializer*);
     SkPixelSerializer* getPixelSerializer() const { return fPixelSerializer; }
 
 private:
     const uint32_t fFlags;
     SkFactorySet* fFactorySet;
     SkWriter32 fWriter;
 
     SkBitmapHeap* fBitmapHeap;
     SkRefCntSet* fTFSet;
 
     SkAutoTUnref<SkPixelSerializer> fPixelSerializer;
 
     // Only used if we do not have an fFactorySet
     SkTHashMap<SkString, uint32_t> fFlattenableDict;
 };
 
 #endif // SkWriteBuffer_DEFINED