getFactory() must return a factory.

src/core/SkWriteBuffer.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 "SkWriteBuffer.h"
 #include "SkBitmap.h"
@@ skipping 252 matching lines @@
     /*
      *  If we have a factoryset, then the first 32bits tell us...
      *       0: failure to write the flattenable
      *      >0: (1-based) index into the SkFactorySet or SkNamedFactorySet
      *  If we don't have a factoryset, then the first "ptr" is either the
      *  factory, or null for failure.
      *
      *  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 (NULL == flattenable) {
         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;
     }
 
+    SkFlattenable::Factory factory = flattenable->getFactory();
+    SkASSERT(factory != NULL);
+
     /*
      *  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
@@ skipping 16 matching lines @@
     // 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.
     size_t offset = fWriter.bytesWritten();
     // now flatten the object
     flattenable->flatten(*this);
     size_t objSize = fWriter.bytesWritten() - offset;
     // record the obj's size
     fWriter.overwriteTAt(offset - sizeof(uint32_t), SkToU32(objSize));
 }