Revert "Remove SkPaintOptionsAndroid"

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"
 #include "SkAutoKern.h"
 #include "SkColorFilter.h"
 #include "SkData.h"
 #include "SkDeviceProperties.h"
 #include "SkDraw.h"
 #include "SkFontDescriptor.h"
 #include "SkFontHost.h"
 #include "SkGlyphCache.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkMaskGamma.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkPaintDefaults.h"
+#include "SkPaintOptionsAndroid.h"
 #include "SkPathEffect.h"
 #include "SkRasterizer.h"
 #include "SkScalar.h"
 #include "SkScalerContext.h"
 #include "SkShader.h"
 #include "SkStringUtils.h"
 #include "SkStroke.h"
 #include "SkTextFormatParams.h"
 #include "SkTextToPathIter.h"
 #include "SkTLazy.h"
@@ skipping 13 matching lines @@
     kPathEffect_DirtyBit          = 1 <<  6,
     kShader_DirtyBit              = 1 <<  7,
     kXfermode_DirtyBit            = 1 <<  8,
     kMaskFilter_DirtyBit          = 1 <<  9,
     kColorFilter_DirtyBit         = 1 << 10,
     kRasterizer_DirtyBit          = 1 << 11,
     kLooper_DirtyBit              = 1 << 12,
     kImageFilter_DirtyBit         = 1 << 13,
     kTypeface_DirtyBit            = 1 << 14,
     kAnnotation_DirtyBit          = 1 << 15,
+    kPaintOptionsAndroid_DirtyBit = 1 << 16,
 };
 
 // define this to get a printf for out-of-range parameter in setters
 // e.g. setTextSize(-1)
 //#define SK_REPORT_API_RANGE_CHECK
 
 #ifdef SK_BUILD_FOR_ANDROID
 #define GEN_ID_INC                  fGenerationID++
 #define GEN_ID_INC_EVAL(expression) if (expression) { fGenerationID++; }
 #else
@@ skipping 25 matching lines @@
     fBitfields.fFlags        = SkPaintDefaults_Flags;
     fBitfields.fCapType      = kDefault_Cap;
     fBitfields.fJoinType     = kDefault_Join;
     fBitfields.fTextAlign    = kLeft_Align;
     fBitfields.fStyle        = kFill_Style;
     fBitfields.fTextEncoding = kUTF8_TextEncoding;
     fBitfields.fHinting      = SkPaintDefaults_Hinting;
 
     fDirtyBits    = 0;
 #ifdef SK_BUILD_FOR_ANDROID
+    new (&fPaintOptionsAndroid) SkPaintOptionsAndroid;
     fGenerationID = 0;
 #endif
 }
 
 SkPaint::SkPaint(const SkPaint& src) {
 #define COPY(field) field = src.field
 #define REF_COPY(field) field = SkSafeRef(src.field)
 
     REF_COPY(fTypeface);
     REF_COPY(fPathEffect);
     REF_COPY(fShader);
     REF_COPY(fXfermode);
     REF_COPY(fMaskFilter);
     REF_COPY(fColorFilter);
     REF_COPY(fRasterizer);
     REF_COPY(fLooper);
     REF_COPY(fImageFilter);
     REF_COPY(fAnnotation);
 
     COPY(fTextSize);
     COPY(fTextScaleX);
     COPY(fTextSkewX);
     COPY(fColor);
     COPY(fWidth);
     COPY(fMiterLimit);
     COPY(fBitfields);
     COPY(fDirtyBits);
 
 #ifdef SK_BUILD_FOR_ANDROID
+    new (&fPaintOptionsAndroid) SkPaintOptionsAndroid(src.fPaintOptionsAndroid);
     COPY(fGenerationID);
 #endif
 
 #undef COPY
 #undef REF_COPY
 }
 
 SkPaint::~SkPaint() {
     SkSafeUnref(fTypeface);
     SkSafeUnref(fPathEffect);
@@ skipping 31 matching lines @@
     COPY(fTextSize);
     COPY(fTextScaleX);
     COPY(fTextSkewX);
     COPY(fColor);
     COPY(fWidth);
     COPY(fMiterLimit);
     COPY(fBitfields);
     COPY(fDirtyBits);
 
 #ifdef SK_BUILD_FOR_ANDROID
+    fPaintOptionsAndroid.~SkPaintOptionsAndroid();
+    new (&fPaintOptionsAndroid) SkPaintOptionsAndroid(src.fPaintOptionsAndroid);
     ++fGenerationID;
 #endif
 
     return *this;
 
 #undef COPY
 #undef REF_COPY
 }
 
 bool operator==(const SkPaint& a, const SkPaint& b) {
 #define EQUAL(field) (a.field == b.field)
     // Don't check fGenerationID or fDirtyBits, which can be different for logically equal paints.
     return EQUAL(fTypeface)
         && EQUAL(fPathEffect)
         && EQUAL(fShader)
         && EQUAL(fXfermode)
         && EQUAL(fMaskFilter)
         && EQUAL(fColorFilter)
         && EQUAL(fRasterizer)
         && EQUAL(fLooper)
         && EQUAL(fImageFilter)
         && EQUAL(fAnnotation)
         && EQUAL(fTextSize)
         && EQUAL(fTextScaleX)
         && EQUAL(fTextSkewX)
         && EQUAL(fColor)
         && EQUAL(fWidth)
         && EQUAL(fMiterLimit)
         && EQUAL(fBitfieldsUInt)
+#ifdef SK_BUILD_FOR_ANDROID
+        && EQUAL(fPaintOptionsAndroid)
+#endif
         ;
 #undef EQUAL
 }
 
 void SkPaint::reset() {
     SkPaint init;
 
 #ifdef SK_BUILD_FOR_ANDROID
     uint32_t oldGenerationID = fGenerationID;
 #endif
     *this = init;
 #ifdef SK_BUILD_FOR_ANDROID
     fGenerationID = oldGenerationID + 1;
 #endif
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 uint32_t SkPaint::getGenerationID() const {
     return fGenerationID;
 }
 
 void SkPaint::setGenerationID(uint32_t generationID) {
     fGenerationID = generationID;
 }
+
+void SkPaint::setPaintOptionsAndroid(const SkPaintOptionsAndroid& options) {
+    if (options != fPaintOptionsAndroid) {
+        fPaintOptionsAndroid = options;
+        GEN_ID_INC;
+        fDirtyBits |= kPaintOptionsAndroid_DirtyBit;
+    }
+}
 #endif
 
 void SkPaint::setFilterLevel(FilterLevel level) {
     GEN_ID_INC_EVAL((unsigned) level != fBitfields.fFilterLevel);
     fBitfields.fFilterLevel = level;
 }
 
 void SkPaint::setHinting(Hinting hintingLevel) {
     GEN_ID_INC_EVAL((unsigned) hintingLevel != fBitfields.fHinting);
     fBitfields.fHinting = hintingLevel;
@@ skipping 1574 matching lines @@
            Also, all existing users of blur have calibrated for linear. */
         rec.ignorePreBlend();
     }
     if (ra) {
         raBuffer.writeFlattenable(ra);
         descSize += raBuffer.bytesWritten();
         entryCount += 1;
         rec.fMaskFormat = SkMask::kA8_Format;   // force antialiasing when we do the scan conversion
     }
 
+#ifdef SK_BUILD_FOR_ANDROID
+    char buffer[128];
+    SkWriteBuffer androidBuffer(buffer, sizeof(buffer));
+    fPaintOptionsAndroid.flatten(androidBuffer);
+    descSize += androidBuffer.bytesWritten();
+    entryCount += 1;
+#endif
+
     ///////////////////////////////////////////////////////////////////////////
     // Now that we're done tweaking the rec, call the PostMakeRec cleanup
     SkScalerContext::PostMakeRec(*this, &rec);
 
     descSize += SkDescriptor::ComputeOverhead(entryCount);
 
     SkAutoDescriptor    ad(descSize);
     SkDescriptor*       desc = ad.getDesc();
 
     desc->init();
     desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
 
+#ifdef SK_BUILD_FOR_ANDROID
+    add_flattenable(desc, kAndroidOpts_SkDescriptorTag, &androidBuffer);
+#endif
+
     if (pe) {
         add_flattenable(desc, kPathEffect_SkDescriptorTag, &peBuffer);
     }
     if (mf) {
         add_flattenable(desc, kMaskFilter_SkDescriptorTag, &mfBuffer);
     }
     if (ra) {
         add_flattenable(desc, kRasterizer_SkDescriptorTag, &raBuffer);
     }
 
@@ skipping 14 matching lines @@
         SkDescriptor*       desc2 = ad2.getDesc();
 
         memset(desc1, 0x00, descSize);
         memset(desc2, 0xFF, descSize);
 
         desc1->init();
         desc2->init();
         desc1->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
         desc2->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
 
+#ifdef SK_BUILD_FOR_ANDROID
+        add_flattenable(desc1, kAndroidOpts_SkDescriptorTag, &androidBuffer);
+        add_flattenable(desc2, kAndroidOpts_SkDescriptorTag, &androidBuffer);
+#endif
+
         if (pe) {
             add_flattenable(desc1, kPathEffect_SkDescriptorTag, &peBuffer);
             add_flattenable(desc2, kPathEffect_SkDescriptorTag, &peBuffer);
         }
         if (mf) {
             add_flattenable(desc1, kMaskFilter_SkDescriptorTag, &mfBuffer);
             add_flattenable(desc2, kMaskFilter_SkDescriptorTag, &mfBuffer);
         }
         if (ra) {
             add_flattenable(desc1, kRasterizer_SkDescriptorTag, &raBuffer);
@@ skipping 196 matching lines @@
         asint(this->getShader()) |
         asint(this->getXfermode()) |
         asint(this->getMaskFilter()) |
         asint(this->getColorFilter()) |
         asint(this->getRasterizer()) |
         asint(this->getLooper()) |
         asint(this->getAnnotation()) |
         asint(this->getImageFilter())) {
         flatFlags |= kHasEffects_FlatFlag;
     }
+#ifdef SK_BUILD_FOR_ANDROID
+    if (this->getPaintOptionsAndroid() != SkPaintOptionsAndroid()) {
+        flatFlags |= kHasNonDefaultPaintOptionsAndroid_FlatFlag;
+    }
+#endif
 
     SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
     uint32_t* ptr = buffer.reserve(kPODPaintSize);
 
     ptr = write_scalar(ptr, this->getTextSize());
     ptr = write_scalar(ptr, this->getTextScaleX());
     ptr = write_scalar(ptr, this->getTextSkewX());
     ptr = write_scalar(ptr, this->getStrokeWidth());
     ptr = write_scalar(ptr, this->getStrokeMiter());
     *ptr++ = this->getColor();
@@ skipping 18 matching lines @@
         buffer.writeFlattenable(this->getLooper());
         buffer.writeFlattenable(this->getImageFilter());
 
         if (fAnnotation) {
             buffer.writeBool(true);
             fAnnotation->writeToBuffer(buffer);
         } else {
             buffer.writeBool(false);
         }
     }
+#ifdef SK_BUILD_FOR_ANDROID
+    if (flatFlags & kHasNonDefaultPaintOptionsAndroid_FlatFlag) {
+        this->getPaintOptionsAndroid().flatten(buffer);
+    }
+#endif
 }
 
 void SkPaint::unflatten(SkReadBuffer& buffer) {
     SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
     const void* podData = buffer.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));
@@ skipping 38 matching lines @@
         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 (buffer.isVersionLT(SkReadBuffer::kRemoveAndroidPaintOpts_Version) &&
-            flatFlags & kHasNonDefaultPaintOptionsAndroid_FlatFlag) {
-        SkString tag;
-        buffer.readUInt();
-        buffer.readString(&tag);
-        buffer.readBool();
+#ifdef SK_BUILD_FOR_ANDROID
+    this->setPaintOptionsAndroid(SkPaintOptionsAndroid());
+#endif
+    if (flatFlags & kHasNonDefaultPaintOptionsAndroid_FlatFlag) {
+        SkPaintOptionsAndroid options;
+        options.unflatten(buffer);
+#ifdef SK_BUILD_FOR_ANDROID
+        this->setPaintOptionsAndroid(options);
+#endif
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkShader* SkPaint::setShader(SkShader* shader) {
     GEN_ID_INC_EVAL(shader != fShader);
     SkRefCnt_SafeAssign(fShader, shader);
     fDirtyBits = set_mask(fDirtyBits, kShader_DirtyBit, shader != NULL);
     return shader;
@@ skipping 438 matching lines @@
     F(Shader);
     F(Xfermode);
     F(MaskFilter);
     F(ColorFilter);
     F(Rasterizer);
     F(Looper);
     F(ImageFilter);
 #undef F
     if (dirty & kTypeface_DirtyBit) buffer.writeTypeface(paint.getTypeface());
     if (dirty & kAnnotation_DirtyBit) paint.getAnnotation()->writeToBuffer(buffer);
+#ifdef SK_BUILD_FOR_ANDROID
+    if (dirty & kPaintOptionsAndroid_DirtyBit) paint.getPaintOptionsAndroid().flatten(buffer);
+#endif
 }
 
 void SkPaint::FlatteningTraits::Unflatten(SkReadBuffer& buffer, SkPaint* paint) {
     const uint32_t dirty = buffer.readUInt();
     paint->fBitfieldsUInt = buffer.readUInt();
     if (dirty == 0) {
         return;
     }
 #define F(field, reader) if (dirty & k##field##_DirtyBit) paint->set##field(buffer.reader())
 // Same function, except it unrefs the object newly set on the paint:
@@ skipping 14 matching lines @@
     F_UNREF(ColorFilter, readColorFilter);
     F_UNREF(Rasterizer,  readRasterizer);
     F_UNREF(Looper,      readDrawLooper);
     F_UNREF(ImageFilter, readImageFilter);
     F(Typeface,    readTypeface);
 #undef F
 #undef F_UNREF
     if (dirty & kAnnotation_DirtyBit) {
         paint->setAnnotation(SkAnnotation::Create(buffer))->unref();
     }
+#ifdef SK_BUILD_FOR_ANDROID
+    if (dirty & kPaintOptionsAndroid_DirtyBit) {
+        SkPaintOptionsAndroid options;
+        options.unflatten(buffer);
+        paint->setPaintOptionsAndroid(options);
+    }
+#endif
     SkASSERT(dirty == paint->fDirtyBits);
 }