force readbuffer clients to use specialized readFoo for flattenables

include/core/SkFlattenableBuffers.h

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkFlattenableBuffers_DEFINED
 #define SkFlattenableBuffers_DEFINED
@@ skipping 11 matching lines @@
 class SkPath;
 class SkPixelRef;
 struct SkRect;
 class SkRefCnt;
 class SkRegion;
 class SkStream;
 class SkString;
 class SkTypeface;
 class SkWStream;
 
+class SkAnnotation;
+class SkColorTable;
+class SkData;
+class SkDataSet;
+class SkDrawLooper;
+class SkLight;
+class SkPixelRef;
+class SkUnitMapper;
+
+enum SkEffectType {
+    kUnknown_SkEffectType,

[sugoi, 2013/10/10 18:15:14]

Having an "unknown" type defeats the purpose of having a known subset of base
classes that we know we can deserialize here, doesn't it ? It feels like we have
a shiny new lock on the front door, but left a window completely open.

+
+    kColorFilter_SkEffectType,
+    kDrawLooper_SkEffectType,
+    kImageFilter_SkEffectType,
+    kMaskFilter_SkEffectType,
+    kPathEffect_SkEffectType,
+    kPixelRef_SkEffectType,
+    kRasterizer_SkEffectType,
+    kShader_SkEffectType,
+    kUnitMapper_SkEffectType,
+    kXfermode_SkEffectType,
+};
+
 class SkFlattenableReadBuffer {
 public:
     SkFlattenableReadBuffer();
     virtual ~SkFlattenableReadBuffer();
 
     bool isOrderedBinaryBuffer() { return NULL != getOrderedBinaryBuffer(); }
     virtual SkOrderedReadBuffer* getOrderedBinaryBuffer() { return NULL; }
 
     enum Flags {
         kCrossProcess_Flag      = 1 << 0,
@@ skipping 14 matching lines @@
     virtual SkFixed readFixed() = 0;
     virtual int32_t readInt() = 0;
     virtual SkScalar readScalar() = 0;
     virtual uint32_t readUInt() = 0;
     virtual int32_t read32() = 0;
 
     // strings -- the caller is responsible for freeing the string contents
     virtual void readString(SkString* string) = 0;
     virtual void* readEncodedString(size_t* length, SkPaint::TextEncoding encoding) = 0;
 
+    SkColorFilter* readColorFilter() {
+        return (SkColorFilter*)this->readFlattenable(kColorFilter_SkEffectType);
+    }
+    SkDrawLooper* readDrawLooper() {
+        return (SkDrawLooper*)this->readFlattenable(kDrawLooper_SkEffectType);
+    }
+    SkImageFilter* readImageFilter() {
+        return (SkImageFilter*)this->readFlattenable(kImageFilter_SkEffectType);
+    }
+    SkMaskFilter* readMaskFilter() {
+        return (SkMaskFilter*)this->readFlattenable(kMaskFilter_SkEffectType);
+    }
+    SkPathEffect* readPathEffect() {
+        return (SkPathEffect*)this->readFlattenable(kPathEffect_SkEffectType);
+    }
+    SkPixelRef* readPixelRef() {
+        return (SkPixelRef*)this->readFlattenable(kPixelRef_SkEffectType);
+    }
+    SkRasterizer* readRasterizer() {
+        return (SkRasterizer*)this->readFlattenable(kRasterizer_SkEffectType);
+    }
+    SkShader* readShader() {
+        return (SkShader*)this->readFlattenable(kShader_SkEffectType);
+    }
+    SkUnitMapper* readUnitMapper() {
+        return (SkUnitMapper*)this->readFlattenable(kUnitMapper_SkEffectType);
+    }
+    SkXfermode* readXfermode() {
+        return (SkXfermode*)this->readFlattenable(kXfermode_SkEffectType);
+    }
+    
+    // Does support subclasses, but is internal to our impl, and is not in
+    // core...
+    //
+    SkLight* readLight() {
+        return (SkLight*)this->readFlattenable(kUnknown_SkEffectType);
+    }
+    
+    // These flattenables do *not* support subclassing, so perhaps need not
+    // actually inherit from SkFlattenable
+    //
+    SkAnnotation* readAnnotation() {
+        return (SkAnnotation*)this->readFlattenable(kUnknown_SkEffectType);
+    }
+    SkColorTable* readColorTable() {
+        return (SkColorTable*)this->readFlattenable(kUnknown_SkEffectType);
+    }
+    SkData* readData() {
+        return (SkData*)this->readFlattenable(kUnknown_SkEffectType);
+    }
+    SkDataSet* readDataSet() {
+        return (SkDataSet*)this->readFlattenable(kUnknown_SkEffectType);
+    }
+
     // common data structures
-    virtual SkFlattenable* readFlattenable() = 0;
     virtual void readPoint(SkPoint* point) = 0;
     virtual void readMatrix(SkMatrix* matrix) = 0;
     virtual void readIRect(SkIRect* rect) = 0;
     virtual void readRect(SkRect* rect) = 0;
     virtual void readRegion(SkRegion* region) = 0;
     virtual void readPath(SkPath* path) = 0;
 
     // binary data and arrays
     virtual uint32_t readByteArray(void* value) = 0;
     virtual uint32_t readColorArray(SkColor* colors) = 0;
@@ skipping 13 matching lines @@
     virtual void readBitmap(SkBitmap* bitmap) = 0;
     virtual SkTypeface* readTypeface() = 0;
 
     // helper function for classes with const SkPoint members
     SkPoint readPoint() {
         SkPoint point;
         this->readPoint(&point);
         return point;
     }
 
-    template <typename T> T* readFlattenableT() {
-        return static_cast<T*>(this->readFlattenable());
-    }
+private:
+    virtual SkFlattenable* readFlattenable(SkEffectType) = 0;
 
-private:
     uint32_t fFlags;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkFlattenableWriteBuffer {
 public:
     SkFlattenableWriteBuffer();
     virtual ~SkFlattenableWriteBuffer();
 
@@ skipping 50 matching lines @@
     bool persistTypeface() const { return (fFlags & kCrossProcess_Flag) != 0; }
 
 protected:
     // A helper function so that each subclass does not have to be a friend of SkFlattenable
     void flattenObject(SkFlattenable* obj, SkFlattenableWriteBuffer& buffer);
 
     uint32_t fFlags;
 };
 
 #endif