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 {
+    kColorFilter_SkEffectType,
+    kDrawLooper_SkEffectType,
+    kImageFilter_SkEffectType,
+    kMaskFilter_SkEffectType,
+    kPathEffect_SkEffectType,
+    kPixelRef_SkEffectType,
+    kRasterizer_SkEffectType,
+    kShader_SkEffectType,
+    kUnitMapper_SkEffectType,
+    kXfermode_SkEffectType,
+    
+    kLight_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;
 
+    SkFlattenable* readEffect(SkEffectType);
+
+    SkColorFilter* readColorFilter() {
+        return (SkColorFilter*)this->readEffect(kColorFilter_SkEffectType);
+    }
+    SkDrawLooper* readDrawLooper() {
+        return (SkDrawLooper*)this->readEffect(kDrawLooper_SkEffectType);
+    }
+    SkImageFilter* readImageFilter() {
+        return (SkImageFilter*)this->readEffect(kImageFilter_SkEffectType);
+    }
+    SkMaskFilter* readMaskFilter() {
+        return (SkMaskFilter*)this->readEffect(kMaskFilter_SkEffectType);
+    }
+    SkPathEffect* readPathEffect() {
+        return (SkPathEffect*)this->readEffect(kPathEffect_SkEffectType);
+    }
+    SkPixelRef* readPixelRef() {
+        return (SkPixelRef*)this->readEffect(kPixelRef_SkEffectType);
+    }
+    SkRasterizer* readRasterizer() {
+        return (SkRasterizer*)this->readEffect(kRasterizer_SkEffectType);
+    }
+    SkShader* readShader() {
+        return (SkShader*)this->readEffect(kShader_SkEffectType);
+    }
+    SkUnitMapper* readUnitMapper() {
+        return (SkUnitMapper*)this->readEffect(kUnitMapper_SkEffectType);
+    }
+    SkXfermode* readXfermode() {
+        return (SkXfermode*)this->readEffect(kXfermode_SkEffectType);
+    }
+    
+    // Does support subclasses, but is internal to our impl, and is not in
+    // core...
+    //
+    SkLight* readLight() {
+        return (SkLight*)this->readEffect(kLight_SkEffectType);
+    }
+    
+    // These flattenables do *not* support subclassing, so perhaps need not
+    // actually inherit from SkFlattenable
+    //
+    SkAnnotation* readAnnotation() {
+        return (SkAnnotation*)this->readAnnotation();
+    }
+    SkColorTable* readColorTable() {
+        return (SkColorTable*)this->readColorTable();
+    }
+    SkData* readData() {
+        return (SkData*)this->readFlattenable();
+    }
+    SkDataSet* readDataSet() {
+        return (SkDataSet*)this->readFlattenable();
+    }
+
     // 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;
     }
 
+#if 0
     template <typename T> T* readFlattenableT() {

[sugoi, 2013/10/09 20:26:55]

Ok, so I've been thinking about this. Even though the public calls are all
strongly typed, I still think it would be much easier to implement / safer if
the inside of these functions are from a (protected/private) call to a template
function and having something like T::GetType() (or maybe
SkFlattenable::GetTypeFromName(T::GetName())) inside that template function.
We'll need to get the type from the name somehow anyway when reading the stream
to do type checking.

In a more abstract way of saying it, I would really appreciate a design that
would not have us manually link an enum with a class in 2 different spots in the
code (which would be here, and at registration time, if we want type checking to
work -- and we'd need some special registration phase for base classes too, to
link each base class with its enum, I guess, which we don't have now), since I
think that would be error prone. If we could simply link an enum value with each
class ONLY at registration time and use the template here to figure out the type
without explicitly writing it in each function, I would find that much cleaner.

         return static_cast<T*>(this->readFlattenable());
     }
+#endif
 
 private:
+    virtual SkFlattenable* readFlattenable() = 0;
+
     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