Initial error handling code

include/core/SkFlattenableBuffers.h

Index: include/core/SkFlattenableBuffers.h
diff --git a/include/core/SkFlattenableBuffers.h b/include/core/SkFlattenableBuffers.h
index 51016c737ffbc705b697809830c0ad0ab9164c5c..ec2b657771b143a79680c6d0b1ab984e8a856f7f 100644
--- a/include/core/SkFlattenableBuffers.h
+++ b/include/core/SkFlattenableBuffers.h
@@ -24,7 +24,6 @@ class SkOrderedWriteBuffer;
 class SkPath;
 class SkPixelRef;
 struct SkRect;
-class SkRefCnt;
 class SkRegion;
 class SkStream;
 class SkString;
@@ -32,19 +31,6 @@ class SkTypeface;
 class SkUnitMapper;
 class SkWStream;
 
-enum SkEffectType {

[sugoi1, 2013/10/16 15:05:32]

Moved to SkFlattenable.h

-    kColorFilter_SkEffectType,
-    kDrawLooper_SkEffectType,
-    kImageFilter_SkEffectType,
-    kMaskFilter_SkEffectType,
-    kPathEffect_SkEffectType,
-    kPixelRef_SkEffectType,
-    kRasterizer_SkEffectType,
-    kShader_SkEffectType,
-    kUnitMapper_SkEffectType,
-    kXfermode_SkEffectType,
-};
-
 class SkFlattenableReadBuffer {
 public:
     SkFlattenableReadBuffer();
@@ -57,14 +43,20 @@ public:
         kCrossProcess_Flag      = 1 << 0,
         kScalarIsFloat_Flag     = 1 << 1,
         kPtrIs64Bit_Flag        = 1 << 2,
+        /** The kValidation_Flag is used to force stream validations (by making
+         * sure that no operation reads past the end of the stream, for example)
+         * and error handling if any reading operation yields an invalid value.
+         */
+        kValidation_Flag        = 1 << 3,
     };
 
     void setFlags(uint32_t flags) { fFlags = flags; }
     uint32_t getFlags() const { return fFlags; }
 
-    bool isCrossProcess() const { return SkToBool(fFlags & kCrossProcess_Flag); }
+    bool isCrossProcess() const { return SkToBool(fFlags & (kCrossProcess_Flag | kValidation_Flag)); }
     bool isScalarFloat() const { return SkToBool(fFlags & kScalarIsFloat_Flag); }
     bool isPtr64Bit() const { return SkToBool(fFlags & kPtrIs64Bit_Flag); }
+    bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
 
     // primitives
     virtual bool readBool() = 0;
@@ -79,38 +71,16 @@ public:
     virtual void readString(SkString* string) = 0;
     virtual void* readEncodedString(size_t* length, SkPaint::TextEncoding encoding) = 0;
 
-    virtual SkFlattenable* readFlattenable(SkEffectType) = 0;

[sugoi1, 2013/10/16 15:05:32]

I'm still going to argue that have a duplicate interface of
readFlattenable(type) + readFoo() is bad. I removed it. If you dislike my
solutions for removing readFlattenable() from the public interface, we can
discuss them, but I really think this has to go.

-
-    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);
-    }
+    SkColorFilter* readColorFilter();
+    SkDrawLooper* readDrawLooper();
+    SkImageFilter* readImageFilter();
+    SkMaskFilter* readMaskFilter();
+    SkPathEffect* readPathEffect();
+    SkPixelRef* readPixelRef();
+    SkRasterizer* readRasterizer();
+    SkShader* readShader();
+    SkUnitMapper* readUnitMapper();
+    SkXfermode* readXfermode();
 
     // common data structures
     virtual void readPoint(SkPoint* point) = 0;
@@ -153,7 +123,20 @@ public:
         return SkData::NewFromMalloc(buffer, len);
     }
 
+    virtual void validate(bool isValid) SK_OVERRIDE {}
+
+protected:
+    virtual SkFlattenable* readFlattenable(

[reed1, 2013/10/16 15:20:20]

Why make this guy protected instead of public?

[sugoi1, 2013/10/16 15:36:26]

So that everyone has to use the specialized readFoo() functions instead of the
generic readFlattenable() function.

+    /**
+      @param type   This parameter is only used when using SkValidatingReadBuffer. It will verify

[reed1, 2013/10/16 15:20:20]

can we move the comment to above the function, instead of inside the parens?

[sugoi1, 2013/10/16 15:36:26]

Done.

+                    that the object about to be deserialized is of the given type or early return
+                    NULL otherwise. The type provided here is either the same type or the type of
+                    one of the base classes of the object to deserialize.
+      */
+        SkEffectType type) = 0;
+
 private:
+    template <typename T> T* readFlattenableT();
     uint32_t fFlags;
 };
 
@@ -205,13 +188,22 @@ public:
 
     enum Flags {
         kCrossProcess_Flag               = 0x01,
+        /** The kValidation_Flag is used here to make sure the write operation
+         *  is symmetric with the read operation using the equivalent flag
+         *  SkFlattenableReadBuffer::kValidation_Flag.
+         */
+        kValidation_Flag                 = 0x02,
     };
 
     uint32_t getFlags() const { return fFlags; }
     void setFlags(uint32_t flags) { fFlags = flags; }
 
     bool isCrossProcess() const {
-        return SkToBool(fFlags & kCrossProcess_Flag);
+        return SkToBool(fFlags & (kCrossProcess_Flag | kValidation_Flag));
+    }
+
+    bool isValidating() const {
+        return SkToBool(fFlags & kValidation_Flag);
     }
 
     bool persistTypeface() const { return (fFlags & kCrossProcess_Flag) != 0; }