Adding size parameter to read array functions

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 81 matching lines @@
 
     // common data structures
     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;
-    virtual uint32_t readIntArray(int32_t* values) = 0;
-    virtual uint32_t readPointArray(SkPoint* points) = 0;
-    virtual uint32_t readScalarArray(SkScalar* values) = 0;
+
+    /**
+      * In the following read.*Array(...) functions, the size parameter specifies the allocation
+      * size (in bytes) of the pointer parameter. If the pointer parameter's size does not match
+      * the size to be read, the pointer parameter's memory will then stay uninitialized, the
+      * cursor will be moved to the end of the stream and, in the case where isValidating() is
+      * true, an error flag will be set internally (see SkValidatingReadBuffer).
+      * If the sizes match, then "size" amount of memory will be read.
+      *
+      * @param size amount of memory expected to be read
+      * @return true if the size parameter matches the size to be read, false otherwise
+      */
+    virtual bool readByteArray(void* value, size_t size) = 0;

[Stephen White, 2013/10/30 20:33:20]

Sorry to get back so late on this one, but would it be better to use a size in
elements, rather than a size in bytes? It seems like it would be a clearer API,
and puts the onus on the implementation to worry about bytes, and lets the
callers just deal with elements.

(That would require changing this particular function to readCharArray(char*,
...) or something.)

[sugoi1, 2013/10/31 14:16:24]

Done. Although I kept void* and assumed that the size parameter is in bytes.

+    virtual bool readColorArray(SkColor* colors, size_t size) = 0;
+    virtual bool readIntArray(int32_t* values, size_t size) = 0;
+    virtual bool readPointArray(SkPoint* points, size_t size) = 0;
+    virtual bool readScalarArray(SkScalar* values, size_t size) = 0;
 
     /** This helper peeks into the buffer and reports back the length of the next array in
      *  the buffer but does not change the state of the buffer.
      */
     virtual uint32_t getArrayCount() = 0;
 
     // helper functions
     virtual void* readFunctionPtr();
     virtual void readPaint(SkPaint* paint);
 
     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;
     }
 
     SkData* readByteArrayAsData() {
         size_t len = this->getArrayCount();
         void* buffer = sk_malloc_throw(len);
-        (void)this->readByteArray(buffer);
+        (void)this->readByteArray(buffer, len);
         return SkData::NewFromMalloc(buffer, len);
     }
 
     virtual void validate(bool isValid) {}
 
 private:
     template <typename T> T* readFlattenableT();
     uint32_t fFlags;
 };
 
@@ skipping 70 matching lines @@
     }
 
 protected:
     // A helper function so that each subclass does not have to be a friend of SkFlattenable
     void flattenObject(const SkFlattenable* obj, SkFlattenableWriteBuffer& buffer);
 
     uint32_t fFlags;
 };
 
 #endif