Initial error handling code

src/core/SkOrderedWriteBuffer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkOrderedWriteBuffer.h"
 #include "SkBitmap.h"
@@ skipping 252 matching lines @@
      *
      *  The distinction is important, since 0-index is 32bits (always), but a
      *  0-functionptr might be 32 or 64 bits.
      */
 
     SkFlattenable::Factory factory = NULL;
     if (flattenable) {
         factory = flattenable->getFactory();
     }
     if (NULL == factory) {
-        if (fFactorySet != NULL || fNamedFactorySet != NULL) {
+        if (this->isValidating()) {
+            this->writeString("");

[Stephen White, 2013/10/21 21:22:37]

Will this change the serialization of SkPictures? If so, we'll need to bump the
version number and regenerate them. (I don't know how this is done or who's on
the hook, I just wanted to raise it in case someone more clueful than me needed
to know.)

[scroggo, 2013/10/21 21:37:22]

I'm guessing this is fine - I think isValidating should return false for
SkPictures.

+            SkASSERT(NULL == flattenable); // We shouldn't get in here in this scenario
+        } else if (fFactorySet != NULL || fNamedFactorySet != NULL) {
             this->write32(0);
         } else {
             this->writeFunctionPtr(NULL);
         }
         return;
     }
 
     /*
      *  We can write 1 of 3 versions of the flattenable:
      *  1.  function-ptr : this is the fastest for the reader, but assumes that
      *      the writer and reader are in the same process.
      *  2.  index into fFactorySet : This is assumes the writer will later
      *      resolve the function-ptrs into strings for its reader. SkPicture
      *      does exactly this, by writing a table of names (matching the indices)
      *      up front in its serialized form.
      *  3.  index into fNamedFactorySet. fNamedFactorySet will also store the
      *      name. SkGPipe uses this technique so it can write the name to its
      *      stream before writing the flattenable.
      */
-    if (fFactorySet) {
+    if (this->isValidating()) {
+        this->writeString(flattenable->getTypeName());
+    } else if (fFactorySet) {
         this->write32(fFactorySet->add(factory));
     } else if (fNamedFactorySet) {
         int32_t index = fNamedFactorySet->find(factory);
         this->write32(index);
         if (0 == index) {
             return;
         }
     } else {
         this->writeFunctionPtr((void*)factory);
     }
 
     // make room for the size of the flattened object
     (void)fWriter.reserve(sizeof(uint32_t));
     // record the current size, so we can subtract after the object writes.
     uint32_t offset = fWriter.size();
     // now flatten the object
     flattenObject(flattenable, *this);
     uint32_t objSize = fWriter.size() - offset;
     // record the obj's size
     *fWriter.peek32(offset - sizeof(uint32_t)) = objSize;
 }