We don't flatten or unflatten SkPaintOptionsAndroid. Reproduce and fix.

src/core/SkPaint.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPaint.h"
 #include "SkAnnotation.h"
@@ skipping 2027 matching lines @@
     }
 
 
     if (buffer.isOrderedBinaryBuffer()) {
         SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
         uint32_t* ptr = buffer.getOrderedBinaryBuffer()->reserve(kPODPaintSize);
 
         ptr = write_scalar(ptr, this->getTextSize());
         ptr = write_scalar(ptr, this->getTextScaleX());
         ptr = write_scalar(ptr, this->getTextSkewX());
-        // Dummy value for obsolete hinting scale factor.  TODO: remove with next picture version
-        ptr = write_scalar(ptr, SK_Scalar1);
         ptr = write_scalar(ptr, this->getStrokeWidth());
         ptr = write_scalar(ptr, this->getStrokeMiter());
         *ptr++ = this->getColor();
         // previously flags:16, textAlign:8, flatFlags:8
         // now flags:16, hinting:4, textAlign:4, flatFlags:8
         *ptr++ = (this->getFlags() << 16) |
                  // hinting added later. 0 in this nibble means use the default.
                  ((this->getHinting()+1) << 12) |
                  (this->getTextAlign() << 8) |
                  flatFlags;
         *ptr++ = pack_4(this->getStrokeCap(), this->getStrokeJoin(),
                         this->getStyle(), this->getTextEncoding());
     } else {
         buffer.writeScalar(fTextSize);
         buffer.writeScalar(fTextScaleX);
         buffer.writeScalar(fTextSkewX);
-        // Dummy value for obsolete hinting scale factor.  TODO: remove with next picture version
-        buffer.writeScalar(SK_Scalar1);
         buffer.writeScalar(fWidth);
         buffer.writeScalar(fMiterLimit);
         buffer.writeColor(fColor);
         buffer.writeUInt(fFlags);
         buffer.writeUInt(fHinting);
         buffer.writeUInt(fTextAlign);
         buffer.writeUInt(flatFlags);
 
         buffer.writeUInt(fCapType);
         buffer.writeUInt(fJoinType);
@@ skipping 10 matching lines @@
         buffer.writeFlattenable(this->getPathEffect());
         buffer.writeFlattenable(this->getShader());
         buffer.writeFlattenable(this->getXfermode());
         buffer.writeFlattenable(this->getMaskFilter());
         buffer.writeFlattenable(this->getColorFilter());
         buffer.writeFlattenable(this->getRasterizer());
         buffer.writeFlattenable(this->getLooper());
         buffer.writeFlattenable(this->getImageFilter());
         buffer.writeFlattenable(this->getAnnotation());
     }
+
+#if SK_BUILD_FOR_ANDROID
+    this->getPaintOptionsAndroid().flatten(buffer);
+#endif
 }
 
 void SkPaint::unflatten(SkFlattenableReadBuffer& buffer) {
     fPrivFlags = 0;
 
     uint8_t flatFlags = 0;
     if (buffer.isOrderedBinaryBuffer()) {
         SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
         const void* podData = buffer.getOrderedBinaryBuffer()->skip(kPODPaintSize);
         const uint32_t* pod = reinterpret_cast<const uint32_t*>(podData);
 
         // the order we read must match the order we wrote in flatten()
         this->setTextSize(read_scalar(pod));
         this->setTextScaleX(read_scalar(pod));
         this->setTextSkewX(read_scalar(pod));
-        // Skip the hinting scalar factor, which is not supported.
-        read_scalar(pod);
         this->setStrokeWidth(read_scalar(pod));
         this->setStrokeMiter(read_scalar(pod));
         this->setColor(*pod++);
 
         // previously flags:16, textAlign:8, flatFlags:8
         // now flags:16, hinting:4, textAlign:4, flatFlags:8
         uint32_t tmp = *pod++;
         this->setFlags(tmp >> 16);
 
         // hinting added later. 0 in this nibble means use the default.
         uint32_t hinting = (tmp >> 12) & 0xF;
         this->setHinting(0 == hinting ? kNormal_Hinting : static_cast<Hinting>(hinting-1));
 
         this->setTextAlign(static_cast<Align>((tmp >> 8) & 0xF));
 
         flatFlags = tmp & 0xFF;
 
         tmp = *pod++;
         this->setStrokeCap(static_cast<Cap>((tmp >> 24) & 0xFF));
         this->setStrokeJoin(static_cast<Join>((tmp >> 16) & 0xFF));
         this->setStyle(static_cast<Style>((tmp >> 8) & 0xFF));
         this->setTextEncoding(static_cast<TextEncoding>((tmp >> 0) & 0xFF));
     } else {
         this->setTextSize(buffer.readScalar());
         this->setTextScaleX(buffer.readScalar());
         this->setTextSkewX(buffer.readScalar());
-        // Skip the hinting scalar factor, which is not supported.
-        buffer.readScalar();
         this->setStrokeWidth(buffer.readScalar());
         this->setStrokeMiter(buffer.readScalar());
         this->setColor(buffer.readColor());
         this->setFlags(buffer.readUInt());
         this->setHinting(static_cast<SkPaint::Hinting>(buffer.readUInt()));
         this->setTextAlign(static_cast<SkPaint::Align>(buffer.readUInt()));
         flatFlags = buffer.readUInt();
 
         this->setStrokeCap(static_cast<SkPaint::Cap>(buffer.readUInt()));
         this->setStrokeJoin(static_cast<SkPaint::Join>(buffer.readUInt()));
@@ skipping 20 matching lines @@
     } else {
         this->setPathEffect(NULL);
         this->setShader(NULL);
         this->setXfermode(NULL);
         this->setMaskFilter(NULL);
         this->setColorFilter(NULL);
         this->setRasterizer(NULL);
         this->setLooper(NULL);
         this->setImageFilter(NULL);
     }
+#if SK_BUILD_FOR_ANDROID
+    SkPaintOptionsAndroid options;
+    options.unflatten(buffer);
+    this->setPaintOptionsAndroid(options);
+#endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkShader* SkPaint::setShader(SkShader* shader) {
     GEN_ID_INC_EVAL(shader != fShader);
     SkRefCnt_SafeAssign(fShader, shader);
     return shader;
 }
 
@@ skipping 380 matching lines @@
             case SkXfermode::kPlus_Mode:
                 return 0 == this->getAlpha();
             case SkXfermode::kDst_Mode:
                 return true;
             default:
                 break;
         }
     }
     return false;
 }