Enable flattening/unflattening with custom unflatten procs

src/core/SkValidatingReadBuffer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkErrorInternals.h"
 #include "SkValidatingReadBuffer.h"
@@ skipping 68 matching lines @@
 }
 
 uint32_t SkValidatingReadBuffer::readUInt() {
     return this->readInt();
 }
 
 int32_t SkValidatingReadBuffer::read32() {
     return this->readInt();
 }
 
+uint8_t SkValidatingReadBuffer::peekByte() {
+    if (fReader.available() <= 0) {
+        fError = true;
+        return 0;
+    }
+    return *((uint8_t*) fReader.peek());
+}
+
 void SkValidatingReadBuffer::readString(SkString* string) {
     const size_t len = this->readUInt();
     const void* ptr = fReader.peek();
     const char* cptr = (const char*)ptr;
 
     // skip over the string + '\0' and then pad to a multiple of 4
     const size_t alignedSize = SkAlign4(len + 1);
     this->skip(alignedSize);
     if (!fError) {
         this->validate(cptr[len] == '\0');
@@ skipping 113 matching lines @@
     SkASSERT(false);
     // TODO: Implement this (securely) when needed
     return nullptr;
 }
 
 bool SkValidatingReadBuffer::validateAvailable(size_t size) {
     return this->validate((size <= SK_MaxU32) && fReader.isAvailable(static_cast<uint32_t>(size)));
 }
 
 SkFlattenable* SkValidatingReadBuffer::readFlattenable(SkFlattenable::Type type) {
-    SkString name;
-    this->readString(&name);
+    uint8_t firstByte = this->peekByte();

[reed1, 2016/04/22 15:06:08]

Can we assert that there is no "factory" here (since in non-validating we check
that before reading the "name"?

If not, lets at least comment how/why this impl is different from the
non-validating one.

[msarett, 2016/04/22 18:54:09]

I've made a protected getter for the factoryCount so that we can verify it is 0
here.

     if (fError) {
         return nullptr;
     }
 
+    SkString name;

[reed1, 2016/04/22 15:06:08]

Is it easy to share this section in a helper function (w/ non-validating
version)?

[msarett, 2016/04/22 18:54:09]

I refactored this, but it ultimately didn't work (failed tests).  The validating
read buffer needs to be able to check for errors after every read.

+    if (firstByte) {
+        // If the first byte is non-zero, the flattenable is specified by a string.
+        this->readString(&name);
+        if (fError) {
+            return nullptr;
+        }
+
+        // Add the string to the dictionary.
+        fFlattenableDict.set(fFlattenableDict.count() + 1, name);
+    } else {
+        // Read the index.  We are guaranteed that the first byte
+        // is zeroed, so we must shift down a byte.
+        uint32_t index = fReader.readU32() >> 8;
+        if (0 == index) {
+            return nullptr; // writer failed to give us the flattenable
+        }
+
+        SkString* namePtr = fFlattenableDict.find(index);
+        SkASSERT(namePtr);
+        name = *namePtr;
+    }
+
     // Is this the type we wanted ?
     const char* cname = name.c_str();
     SkFlattenable::Type baseType;
     if (!SkFlattenable::NameToType(cname, &baseType) || (baseType != type)) {
         return nullptr;
     }
 
-    SkFlattenable::Factory factory = SkFlattenable::NameToFactory(cname);
-    if (nullptr == factory) {
-        return nullptr; // writer failed to give us the flattenable
+    // Get the factory for this flattenable.
+    SkFlattenable::Factory factory = this->getCustomFactory(name);
+    if (!factory) {
+        factory = SkFlattenable::NameToFactory(cname);
+        if (!factory) {
+            return nullptr; // writer failed to give us the flattenable
+        }
     }
 
-    // if we get here, factory may still be null, but if that is the case, the
-    // failure was ours, not the writer.
+    // If we get here, the factory is non-null.
     sk_sp<SkFlattenable> obj;
     uint32_t sizeRecorded = this->readUInt();
-    if (factory) {
-        size_t offset = fReader.offset();
-        obj = (*factory)(*this);
-        // check that we read the amount we expected
-        size_t sizeRead = fReader.offset() - offset;
-        this->validate(sizeRecorded == sizeRead);
-        if (fError) {
-            obj = nullptr;
-        }
-    } else {
-        // we must skip the remaining data
-        this->skip(sizeRecorded);
-        SkASSERT(false);
+    size_t offset = fReader.offset();
+    obj = (*factory)(*this);
+    // check that we read the amount we expected
+    size_t sizeRead = fReader.offset() - offset;
+    this->validate(sizeRecorded == sizeRead);
+    if (fError) {
+        obj = nullptr;
     }
     return obj.release();
 }
 
 void SkValidatingReadBuffer::skipFlattenable() {
     SkString name;
     this->readString(&name);
     if (fError) {
         return;
     }
     uint32_t sizeRecorded = this->readUInt();
     this->skip(sizeRecorded);
 }