SkData need not be a Flattenable, since it does not need subclass/factories

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
 
 #include "SkColor.h"
+#include "SkData.h"
 #include "SkPaint.h"
 #include "SkPoint.h"
 
 class SkBitmap;
 class SkFlattenable;
 struct SkIRect;
 class SkMatrix;
 class SkOrderedReadBuffer;
 class SkOrderedWriteBuffer;
 class SkPath;
@@ skipping 67 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;
     }
+    
+    SkData* readByteArrayAsData() {

[mtklein, 2013/10/10 21:32:03]

Mentioning byte array here seems weird to me.  readData() / writeData()?   We
don't really include the details of encoding in any of the other names.

[sugoi, 2013/10/11 12:03:35]

Shouldn't it be pure virtual and defined in SkOrderedReadBuffer, like most the
other ones above ? I know it uses readByteArray, but I can foresee that a secure
version of this code may add a few safety checks in here.

[sugoi, 2013/10/11 12:03:35]

+1

[reed1, 2013/10/14 13:32:14]

I think there is no value-added to storing SkData in any separate way from just
an array of bytes, since that is precisely what it is (our public docs make it
clear that we don't interpret its contents in any way).

I see this has purely a helper function (since we have several internal
callers). read/write byte-array is already virtual, so this builds upon that.

Put another way, reading an SkData is just a convenience/choice by the caller. A
different caller may want to read the contents into a buffer of their own
choosing, and we should completely support that (since there is no loss of
information or abstraction). Thus we document that SkData read/writes are built
upon the lower-level byte-array interface.

+        size_t len = this->getArrayCount();
+        void* buffer = sk_malloc_throw(len);
+        (void)this->readByteArray(buffer);
+        return SkData::NewFromMalloc(buffer, len);
+    }
 
     template <typename T> T* readFlattenableT() {
         return static_cast<T*>(this->readFlattenable());
     }
 
 private:
     uint32_t fFlags;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 48 matching lines @@
 
     uint32_t getFlags() const { return fFlags; }
     void setFlags(uint32_t flags) { fFlags = flags; }
 
     bool isCrossProcess() const {
         return SkToBool(fFlags & kCrossProcess_Flag);
     }
 
     bool persistTypeface() const { return (fFlags & kCrossProcess_Flag) != 0; }
 
+    void writeDataAsByteArray(SkData* data) {
+        this->writeByteArray(data->data(), data->size());
+    }
+
 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