Initial error handling code

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 23 matching lines @@
     SkFlattenableReadBuffer();
     virtual ~SkFlattenableReadBuffer();
 
     bool isOrderedBinaryBuffer() { return NULL != getOrderedBinaryBuffer(); }
     virtual SkOrderedReadBuffer* getOrderedBinaryBuffer() { return NULL; }
 
     enum Flags {
         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;
     virtual SkColor readColor() = 0;
     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;
 
     // common data structures
-    virtual SkFlattenable* readFlattenable() = 0;
+    virtual SkFlattenable* readFlattenable(
+    /**
+      @param type   This parameter is only used when using SkValidatingReadBuffer. It will verify
+                    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. This can effectively be
+                    bypassed by providing the type SkFlattenable::kSkFlattenable_Type here, since

[mtklein, 2013/10/07 19:29:56]

kSkFlattenableType_Type -> GetName()?

[sugoi1, 2013/10/08 20:23:10]

Done.

+                    SkFlattenable is a base class to all other classes that can be deserialized.
+      */
+        const char* name = SkFlattenable::GetName()) = 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 14 matching lines @@
     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());
+        return static_cast<T*>(this->readFlattenable(T::GetName()));
     }
 
+    void validate(bool isValid) {
+        fError = fError || !isValid;
+    }
+
+protected:
+    bool fError;

[mtklein, 2013/10/07 19:29:56]

This seems a little odd to add this state here if it's only used by the
validating read buffer.  

Can we do this with:

virtual bool error() const { return false; }
virtual void validate(bool isValid) {}

and have the validating buffer override these?  Actually, maybe we don't even
need error()?

[sugoi1, 2013/10/08 20:23:10]

Done.

+
 private:
     uint32_t fFlags;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkFlattenableWriteBuffer {
 public:
     SkFlattenableWriteBuffer();
     virtual ~SkFlattenableWriteBuffer();
@@ skipping 32 matching lines @@
     virtual void writeFunctionPtr(void* ptr);
     virtual void writePaint(const SkPaint& paint);
 
     virtual void writeBitmap(const SkBitmap& bitmap) = 0;
     virtual void writeTypeface(SkTypeface* typeface) = 0;
 
     virtual bool writeToStream(SkWStream*) = 0;
 
     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

[mtklein, 2013/10/07 19:29:56]

I don't think I understand what this comment is trying to say.

[sugoi1, 2013/10/08 20:23:10]

We can phrase it any other way, but essentially : The reading operation is the
one that needs to be secure, while the writing operation can send any stream it
wants (since the stream can be hacked after it is written, we can't really make
any security assumptions on this side). In this case, since the secure version
of the reading operation has its own way of reading the data, then the writing
operation must write the data in a way that's expected by the reading operation.
Ping me on the chat if this isn't clear.

+         *  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; }
 
 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