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("");
+            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;
 }