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 isSecure() const { return SkToBool(fFlags & kValidation_Flag); }

[reed1, 2013/09/04 18:49:36]

isValidating()?

[sugoi1, 2013/09/04 20:14:52]

Done.

 
     // 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;
 
@@ skipping 33 matching lines @@
     SkPoint readPoint() {
         SkPoint point;
         this->readPoint(&point);
         return point;
     }
 
     template <typename T> T* readFlattenableT() {
         return static_cast<T*>(this->readFlattenable());
     }
 
+    void validateData(bool isValid) {
+        fError |= !isValid;
+    }
+
+protected:
+    bool fError;
+
 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
+         *  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 isSecure() const {

[reed1, 2013/09/04 18:49:36]

isValidating()?

[sugoi1, 2013/09/04 20:14:52]

Done.

+        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