WIP -- separate out Parts from SkPaint

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 17 matching lines @@
 #include "SkScalerContext.h"
 #include "SkShader.h"
 #include "SkStringUtils.h"
 #include "SkStroke.h"
 #include "SkTextFormatParams.h"
 #include "SkTextToPathIter.h"
 #include "SkTLazy.h"
 #include "SkTypeface.h"
 #include "SkXfermode.h"
 
+#define SkPaintParts_SafeAssign(field, value)   SkRefCnt_SafeAssign(fParts.field, value)
+
+bool SkPaintParts::operator==(const SkPaintParts& other) const {
+#define EQUAL(field) (this->field == other.field)
+    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(fBitfields)
+        ;
+#undef EQUAL
+}
+
+///////////
+
+
 enum {
     kColor_DirtyBit               = 1 <<  0,
     kTextSize_DirtyBit            = 1 <<  1,
     kTextScaleX_DirtyBit          = 1 <<  2,
     kTextSkewX_DirtyBit           = 1 <<  3,
     kStrokeWidth_DirtyBit         = 1 <<  4,
     kStrokeMiter_DirtyBit         = 1 <<  5,
 
     kPOD_DirtyBitMask             = 63,
 
@@ skipping 16 matching lines @@
 
 #ifdef SK_BUILD_FOR_ANDROID
 #define GEN_ID_INC                  fGenerationID++
 #define GEN_ID_INC_EVAL(expression) if (expression) { fGenerationID++; }
 #else
 #define GEN_ID_INC
 #define GEN_ID_INC_EVAL(expression)
 #endif
 
 SkPaint::SkPaint() {
-    fTypeface    = NULL;
-    fPathEffect  = NULL;
-    fShader      = NULL;
-    fXfermode    = NULL;
-    fMaskFilter  = NULL;
-    fColorFilter = NULL;
-    fRasterizer  = NULL;
-    fLooper      = NULL;
-    fImageFilter = NULL;
-    fAnnotation  = NULL;
+    // set any non-zero values in fParts
 
-    fTextSize     = SkPaintDefaults_TextSize;
-    fTextScaleX   = SK_Scalar1;
-    fTextSkewX    = 0;
-    fColor        = SK_ColorBLACK;
-    fWidth        = 0;
-    fMiterLimit   = SkPaintDefaults_MiterLimit;
+    fParts.fTextSize     = SkPaintDefaults_TextSize;
+    fParts.fTextScaleX   = SK_Scalar1;
+    fParts.fColor        = SK_ColorBLACK;
+    fParts.fMiterLimit   = SkPaintDefaults_MiterLimit;
 
-    // Zero all bitfields, then set some non-zero defaults.
-    fBitfields    = 0;
-    fFlags        = SkPaintDefaults_Flags;
-    fCapType      = kDefault_Cap;
-    fJoinType     = kDefault_Join;
-    fTextAlign    = kLeft_Align;
-    fStyle        = kFill_Style;
-    fTextEncoding = kUTF8_TextEncoding;
-    fHinting      = SkPaintDefaults_Hinting;
+    fParts.fFlags        = SkPaintDefaults_Flags;
+    fParts.fCapType      = SkPaintParts::kDefault_Cap;
+    fParts.fJoinType     = SkPaintParts::kDefault_Join;
+    fParts.fTextAlign    = SkPaintParts::kLeft_Align;
+    fParts.fStyle        = SkPaintParts::kFill_Style;
+    fParts.fTextEncoding = kUTF8_TextEncoding;
+    fParts.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)
+#define COPY(field) fParts.field = src.fParts.field
+#define REF_COPY(field) fParts.field = SkSafeRef(src.fParts.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);
+
+    fDirtyBits = src.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);
-    SkSafeUnref(fShader);
-    SkSafeUnref(fXfermode);
-    SkSafeUnref(fMaskFilter);
-    SkSafeUnref(fColorFilter);
-    SkSafeUnref(fRasterizer);
-    SkSafeUnref(fLooper);
-    SkSafeUnref(fImageFilter);
-    SkSafeUnref(fAnnotation);
+    SkSafeUnref(fParts.fTypeface);
+    SkSafeUnref(fParts.fPathEffect);
+    SkSafeUnref(fParts.fShader);
+    SkSafeUnref(fParts.fXfermode);
+    SkSafeUnref(fParts.fMaskFilter);
+    SkSafeUnref(fParts.fColorFilter);
+    SkSafeUnref(fParts.fRasterizer);
+    SkSafeUnref(fParts.fLooper);
+    SkSafeUnref(fParts.fImageFilter);
+    SkSafeUnref(fParts.fAnnotation);
 }
 
 SkPaint& SkPaint::operator=(const SkPaint& src) {
-#define COPY(field) field = src.field
-#define REF_COPY(field) SkSafeUnref(field); field = SkSafeRef(src.field)
+#define COPY(field) fParts.field = src.fParts.field
+#define REF_COPY(field) SkSafeUnref(fParts.field); fParts.field = SkSafeRef(src.fParts.field)
 
     SkASSERT(&src);
 
     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);
+    
+    fDirtyBits = src.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(fBitfields)
+    if (a.fParts != b.fParts) {
+        return false;
+    }
 #ifdef SK_BUILD_FOR_ANDROID
-        && EQUAL(fPaintOptionsAndroid)
+    if (fPaintOptionsAndroid != b.fPaintOptionsAndroid) {
+        return false;
+    }
 #endif
-        ;
-#undef EQUAL
+    return true;
 }
 
 void SkPaint::reset() {
     SkPaint init;
 
 #ifdef SK_BUILD_FOR_ANDROID
     uint32_t oldGenerationID = fGenerationID;
 #endif
     *this = init;
 #ifdef SK_BUILD_FOR_ANDROID
@@ skipping 20 matching lines @@
     if (options != fPaintOptionsAndroid) {
         fPaintOptionsAndroid = options;
         GEN_ID_INC;
         fDirtyBits |= kPaintOptionsAndroid_DirtyBit;
     }
 }
 #endif
 
 void SkPaint::setFilterLevel(FilterLevel level) {
     GEN_ID_INC_EVAL((unsigned) level != fFilterLevel);
-    fFilterLevel = level;
+    fParts.setFilterLevel(static_cast<SkPaintParts::FilterLevel>(level));
 }
 
 void SkPaint::setHinting(Hinting hintingLevel) {
     GEN_ID_INC_EVAL((unsigned) hintingLevel != fHinting);
-    fHinting = hintingLevel;
+    fParts.setHinting(static_cast<SkPaintParts::Hinting>(hintingLevel));
 }
 
 void SkPaint::setFlags(uint32_t flags) {
     GEN_ID_INC_EVAL(fFlags != flags);
-    fFlags = flags;
+    fParts.setFlags(flags);
 }
 
 void SkPaint::setAntiAlias(bool doAA) {
-    this->setFlags(SkSetClearMask(fFlags, doAA, kAntiAlias_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doAA, kAntiAlias_Flag));
 }
 
 void SkPaint::setDither(bool doDither) {
-    this->setFlags(SkSetClearMask(fFlags, doDither, kDither_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doDither, kDither_Flag));
 }
 
 void SkPaint::setSubpixelText(bool doSubpixel) {
-    this->setFlags(SkSetClearMask(fFlags, doSubpixel, kSubpixelText_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doSubpixel, kSubpixelText_Flag));
 }
 
 void SkPaint::setLCDRenderText(bool doLCDRender) {
-    this->setFlags(SkSetClearMask(fFlags, doLCDRender, kLCDRenderText_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doLCDRender, kLCDRenderText_Flag));
 }
 
 void SkPaint::setEmbeddedBitmapText(bool doEmbeddedBitmapText) {
-    this->setFlags(SkSetClearMask(fFlags, doEmbeddedBitmapText, kEmbeddedBitmapText_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doEmbeddedBitmapText, kEmbeddedBitmapText_Flag));
 }
 
 void SkPaint::setAutohinted(bool useAutohinter) {
-    this->setFlags(SkSetClearMask(fFlags, useAutohinter, kAutoHinting_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), useAutohinter, kAutoHinting_Flag));
 }
 
 void SkPaint::setLinearText(bool doLinearText) {
-    this->setFlags(SkSetClearMask(fFlags, doLinearText, kLinearText_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doLinearText, kLinearText_Flag));
 }
 
 void SkPaint::setVerticalText(bool doVertical) {
-    this->setFlags(SkSetClearMask(fFlags, doVertical, kVerticalText_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doVertical, kVerticalText_Flag));
 }
 
 void SkPaint::setUnderlineText(bool doUnderline) {
-    this->setFlags(SkSetClearMask(fFlags, doUnderline, kUnderlineText_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doUnderline, kUnderlineText_Flag));
 }
 
 void SkPaint::setStrikeThruText(bool doStrikeThru) {
-    this->setFlags(SkSetClearMask(fFlags, doStrikeThru, kStrikeThruText_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doStrikeThru, kStrikeThruText_Flag));
 }
 
 void SkPaint::setFakeBoldText(bool doFakeBold) {
-    this->setFlags(SkSetClearMask(fFlags, doFakeBold, kFakeBoldText_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doFakeBold, kFakeBoldText_Flag));
 }
 
 void SkPaint::setDevKernText(bool doDevKern) {
-    this->setFlags(SkSetClearMask(fFlags, doDevKern, kDevKernText_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doDevKern, kDevKernText_Flag));
 }
 
 void SkPaint::setDistanceFieldTextTEMP(bool doDistanceFieldText) {
-    this->setFlags(SkSetClearMask(fFlags, doDistanceFieldText, kDistanceFieldTextTEMP_Flag));
+    this->setFlags(SkSetClearMask(fParts.getFlags(), doDistanceFieldText, kDistanceFieldTextTEMP_Flag));
 }
 
 void SkPaint::setStyle(Style style) {
     if ((unsigned)style < kStyleCount) {
         GEN_ID_INC_EVAL((unsigned)style != fStyle);
-        fStyle = style;
+        fParts.setStyle(static_cast<SkPaintParts::Style>(style));
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setStyle(%d) out of range\n", style);
 #endif
     }
 }
 
 void SkPaint::setColor(SkColor color) {
     GEN_ID_INC_EVAL(color != fColor);
-    fColor = color;
+    fParts.setColor(color);
     fDirtyBits |= kColor_DirtyBit;
 }
 
 void SkPaint::setAlpha(U8CPU a) {
-    this->setColor(SkColorSetARGB(a, SkColorGetR(fColor),
-                                  SkColorGetG(fColor), SkColorGetB(fColor)));
+    const SkColor c = fParts.getColor();
+    this->setColor(SkColorSetARGB(a, SkColorGetR(c), SkColorGetG(c), SkColorGetB(c)));
 }
 
 void SkPaint::setARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
     this->setColor(SkColorSetARGB(a, r, g, b));
 }
 
 void SkPaint::setStrokeWidth(SkScalar width) {
     if (width >= 0) {
         GEN_ID_INC_EVAL(width != fWidth);
-        fWidth = width;
+        fParts.setStrokeWidth(width);
         fDirtyBits |= kStrokeWidth_DirtyBit;
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setStrokeWidth() called with negative value\n");
 #endif
     }
 }
 
 void SkPaint::setStrokeMiter(SkScalar limit) {
     if (limit >= 0) {
         GEN_ID_INC_EVAL(limit != fMiterLimit);
-        fMiterLimit = limit;
+        fParts.setStrokeMiter(limit);
         fDirtyBits |= kStrokeMiter_DirtyBit;
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setStrokeMiter() called with negative value\n");
 #endif
     }
 }
 
 void SkPaint::setStrokeCap(Cap ct) {
     if ((unsigned)ct < kCapCount) {
         GEN_ID_INC_EVAL((unsigned)ct != fCapType);
-        fCapType = SkToU8(ct);
+        fParts.setStrokeCap(static_cast<SkPaintParts::Cap>(ct));
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setStrokeCap(%d) out of range\n", ct);
 #endif
     }
 }
 
 void SkPaint::setStrokeJoin(Join jt) {
     if ((unsigned)jt < kJoinCount) {
         GEN_ID_INC_EVAL((unsigned)jt != fJoinType);
-        fJoinType = SkToU8(jt);
+        fParts.setStrokeJoin(static_cast<SkPaintParts::Join>(jt));
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setStrokeJoin(%d) out of range\n", jt);
 #endif
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkPaint::setTextAlign(Align align) {
     if ((unsigned)align < kAlignCount) {
         GEN_ID_INC_EVAL((unsigned)align != fTextAlign);
-        fTextAlign = SkToU8(align);
+        fParts.setTextAlign(static_cast<SkPaintParts::Align>(align));
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setTextAlign(%d) out of range\n", align);
 #endif
     }
 }
 
 void SkPaint::setTextSize(SkScalar ts) {
     if (ts >= 0) {
         GEN_ID_INC_EVAL(ts != fTextSize);
-        fTextSize = ts;
+        fParts.setTextSize(ts);
         fDirtyBits |= kTextSize_DirtyBit;
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setTextSize() called with negative value\n");
 #endif
     }
 }
 
 void SkPaint::setTextScaleX(SkScalar scaleX) {
     GEN_ID_INC_EVAL(scaleX != fTextScaleX);
-    fTextScaleX = scaleX;
+    fParts.setTextScaleX(scaleX);
     fDirtyBits |= kTextScaleX_DirtyBit;
 }
 
 void SkPaint::setTextSkewX(SkScalar skewX) {
     GEN_ID_INC_EVAL(skewX != fTextSkewX);
-    fTextSkewX = skewX;
+    fParts.setTextSkewX(skewX);
     fDirtyBits |= kTextSkewX_DirtyBit;
 }
 
 void SkPaint::setTextEncoding(TextEncoding encoding) {
     if ((unsigned)encoding <= kGlyphID_TextEncoding) {
         GEN_ID_INC_EVAL((unsigned)encoding != fTextEncoding);
-        fTextEncoding = encoding;
+        fParts.setTextEncoding(static_cast<SkPaintParts::TextEncoding>(encoding));
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setTextEncoding(%d) out of range\n", encoding);
 #endif
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Returns dst with the given bitmask enabled or disabled, depending on value.
 inline static uint32_t set_mask(uint32_t dst, uint32_t bitmask, bool value) {
     return value ? (dst | bitmask) : (dst & ~bitmask);
 }
 
 SkTypeface* SkPaint::setTypeface(SkTypeface* font) {
-    SkRefCnt_SafeAssign(fTypeface, font);
     GEN_ID_INC;
+    SkPaintParts_SafeAssign(fTypeface, font);
     fDirtyBits = set_mask(fDirtyBits, kTypeface_DirtyBit, font != NULL);
     return font;
 }
 
 SkRasterizer* SkPaint::setRasterizer(SkRasterizer* r) {
-    SkRefCnt_SafeAssign(fRasterizer, r);
     GEN_ID_INC;
+    SkPaintParts_SafeAssign(fRasterizer, r);
     fDirtyBits = set_mask(fDirtyBits, kRasterizer_DirtyBit, r != NULL);
     return r;
 }
 
 SkDrawLooper* SkPaint::setLooper(SkDrawLooper* looper) {
-    SkRefCnt_SafeAssign(fLooper, looper);
     GEN_ID_INC;
+    SkPaintParts_SafeAssign(fLooper, looper);
     fDirtyBits = set_mask(fDirtyBits, kLooper_DirtyBit, looper != NULL);
     return looper;
 }
 
 SkImageFilter* SkPaint::setImageFilter(SkImageFilter* imageFilter) {
-    SkRefCnt_SafeAssign(fImageFilter, imageFilter);
     GEN_ID_INC;
+    SkPaintParts_SafeAssign(fImageFilter, imageFilter);
     fDirtyBits = set_mask(fDirtyBits, kImageFilter_DirtyBit, imageFilter != NULL);
     return imageFilter;
 }
 
 SkAnnotation* SkPaint::setAnnotation(SkAnnotation* annotation) {
-    SkRefCnt_SafeAssign(fAnnotation, annotation);
     GEN_ID_INC;
+    SkPaintParts_SafeAssign(fAnnotation, annotation);
     fDirtyBits = set_mask(fDirtyBits, kAnnotation_DirtyBit, annotation != NULL);
     return annotation;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkScalar mag2(SkScalar x, SkScalar y) {
     return x * x + y * y;
 }
 
@@ skipping 461 matching lines @@
         sk_getMetrics_utf32_00,
         sk_getMetrics_glyph_00,
 
         sk_getMetrics_utf8_xy,
         sk_getMetrics_utf16_xy,
         sk_getMetrics_utf32_xy,
         sk_getMetrics_glyph_xy
     };
 
     unsigned index = this->getTextEncoding();
-    if (fFlags & kSubpixelText_Flag) {
+    if (this->getFlags() & kSubpixelText_Flag) {
         index += 4;
     }
 
     SkASSERT(index < SK_ARRAY_COUNT(gDrawCacheProcs));
     return gDrawCacheProcs[index];
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #define TEXT_AS_PATHS_PAINT_FLAGS_TO_IGNORE (   \
 SkPaint::kDevKernText_Flag          |       \
 SkPaint::kLinearText_Flag           |       \
 SkPaint::kLCDRenderText_Flag        |       \
 SkPaint::kEmbeddedBitmapText_Flag   |       \
 SkPaint::kAutoHinting_Flag          |       \
 SkPaint::kGenA8FromLCD_Flag )
 
 SkScalar SkPaint::setupForAsPaths() {
     uint32_t flags = this->getFlags();
     // clear the flags we don't care about
     flags &= ~TEXT_AS_PATHS_PAINT_FLAGS_TO_IGNORE;
     // set the flags we do care about
     flags |= SkPaint::kSubpixelText_Flag;
 
     this->setFlags(flags);
     this->setHinting(SkPaint::kNo_Hinting);
 
-    SkScalar textSize = fTextSize;
+    SkScalar textSize = this->getTextSize();
     this->setTextSize(kCanonicalTextSizeForPaths);
     return textSize / kCanonicalTextSizeForPaths;
 }
 
 class SkCanonicalizePaint {
 public:
     SkCanonicalizePaint(const SkPaint& paint) : fPaint(&paint), fScale(0) {
         if (paint.isLinearText() || paint.tooBigToUseCache()) {
             SkPaint* p = fLazy.set(paint);
             fScale = p->setupForAsPaths();
@@ skipping 195 matching lines @@
 size_t SkPaint::breakText(const void* textD, size_t length, SkScalar maxWidth,
                           SkScalar* measuredWidth,
                           TextBufferDirection tbd) const {
     if (0 == length || 0 >= maxWidth) {
         if (measuredWidth) {
             *measuredWidth = 0;
         }
         return 0;
     }
 
-    if (0 == fTextSize) {
+    if (0 == this->getTextSize()) {
         if (measuredWidth) {
             *measuredWidth = 0;
         }
         return length;
     }
 
     SkASSERT(textD != NULL);
     const char* text = (const char*)textD;
 
     SkCanonicalizePaint canon(*this);
@@ skipping 721 matching lines @@
 
         SkASSERT(descSize == desc1->getLength());
         SkASSERT(descSize == desc2->getLength());
         desc1->computeChecksum();
         desc2->computeChecksum();
         SkASSERT(!memcmp(desc, desc1, descSize));
         SkASSERT(!memcmp(desc, desc2, descSize));
     }
 #endif
 
-    proc(fTypeface, desc, context);
+    proc(this->getTypeface(), desc, context);
 }
 
 SkGlyphCache* SkPaint::detachCache(const SkDeviceProperties* deviceProperties,
                                    const SkMatrix* deviceMatrix) const {
     SkGlyphCache* cache;
     this->descriptorProc(deviceProperties, deviceMatrix, DetachDescProc, &cache, false);
     return cache;
 }
 
 /**
@@ skipping 181 matching lines @@
     if (flatFlags & kHasEffects_FlatFlag) {
         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());
 
-        if (fAnnotation) {
+        if (this->getAnnotation()) {
             buffer.writeBool(true);
-            fAnnotation->writeToBuffer(buffer);
+            this->getAnnotation()->writeToBuffer(buffer);
         } else {
             buffer.writeBool(false);
         }
     }
 #ifdef SK_BUILD_FOR_ANDROID
     if (flatFlags & kHasNonDefaultPaintOptionsAndroid_FlatFlag) {
         this->getPaintOptionsAndroid().flatten(buffer);
     }
 #endif
 }
@@ skipping 64 matching lines @@
 #ifdef SK_BUILD_FOR_ANDROID
         this->setPaintOptionsAndroid(options);
 #endif
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkShader* SkPaint::setShader(SkShader* shader) {
     GEN_ID_INC_EVAL(shader != fShader);
-    SkRefCnt_SafeAssign(fShader, shader);
+    SkPaintParts_SafeAssign(fShader, shader);
     fDirtyBits = set_mask(fDirtyBits, kShader_DirtyBit, shader != NULL);
     return shader;
 }
 
 SkColorFilter* SkPaint::setColorFilter(SkColorFilter* filter) {
     GEN_ID_INC_EVAL(filter != fColorFilter);
-    SkRefCnt_SafeAssign(fColorFilter, filter);
+    SkPaintParts_SafeAssign(fColorFilter, filter);
     fDirtyBits = set_mask(fDirtyBits, kColorFilter_DirtyBit, filter != NULL);
     return filter;
 }
 
 SkXfermode* SkPaint::setXfermode(SkXfermode* mode) {
     GEN_ID_INC_EVAL(mode != fXfermode);
-    SkRefCnt_SafeAssign(fXfermode, mode);
+    SkPaintParts_SafeAssign(fXfermode, mode);
     fDirtyBits = set_mask(fDirtyBits, kXfermode_DirtyBit, mode != NULL);
     return mode;
 }
 
 SkXfermode* SkPaint::setXfermodeMode(SkXfermode::Mode mode) {
-    SkSafeUnref(fXfermode);
-    fXfermode = SkXfermode::Create(mode);
+    SkSafeUnref(fParts.fXfermode);
+    fParts.fXfermode = SkXfermode::Create(mode);
     GEN_ID_INC;
-    fDirtyBits = set_mask(fDirtyBits, kXfermode_DirtyBit, fXfermode != NULL);
-    return fXfermode;
+    fDirtyBits = set_mask(fDirtyBits, kXfermode_DirtyBit, fParts.fXfermode != NULL);
+    return fParts.fXfermode;
 }
 
 SkPathEffect* SkPaint::setPathEffect(SkPathEffect* effect) {
     GEN_ID_INC_EVAL(effect != fPathEffect);
-    SkRefCnt_SafeAssign(fPathEffect, effect);
+    SkPaintParts_SafeAssign(fPathEffect, effect);
     fDirtyBits = set_mask(fDirtyBits, kPathEffect_DirtyBit, effect != NULL);
     return effect;
 }
 
 SkMaskFilter* SkPaint::setMaskFilter(SkMaskFilter* filter) {
     GEN_ID_INC_EVAL(filter != fMaskFilter);
-    SkRefCnt_SafeAssign(fMaskFilter, filter);
+    SkPaintParts_SafeAssign(fMaskFilter, filter);
     fDirtyBits = set_mask(fDirtyBits, kMaskFilter_DirtyBit, filter != NULL);
     return filter;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkPaint::getFillPath(const SkPath& src, SkPath* dst,
                           const SkRect* cullRect) const {
     SkStrokeRec rec(*this);
 
     const SkPath* srcPtr = &src;
     SkPath tmpPath;
 
-    if (fPathEffect && fPathEffect->filterPath(&tmpPath, src, &rec, cullRect)) {
+    SkPathEffect* pe = this->getPathEffect();
+    if (pe && pe->filterPath(&tmpPath, src, &rec, cullRect)) {
         srcPtr = &tmpPath;
     }
 
     if (!rec.applyToPath(dst, *srcPtr)) {
         if (srcPtr == &tmpPath) {
             // If path's were copy-on-write, this trick would not be needed.
             // As it is, we want to save making a deep-copy from tmpPath -> dst
             // since we know we're just going to delete tmpPath when we return,
             // so the swap saves that copy.
             dst->swap(tmpPath);
@@ skipping 316 matching lines @@
             *xpos = fXPos;
         }
         return true;
     }
     return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkPaint::nothingToDraw() const {
-    if (fLooper) {
+    if (this->getLooper()) {
         return false;
     }
     SkXfermode::Mode mode;
-    if (SkXfermode::AsMode(fXfermode, &mode)) {
+    if (SkXfermode::AsMode(this->getXfermode(), &mode)) {
         switch (mode) {
             case SkXfermode::kSrcOver_Mode:
             case SkXfermode::kSrcATop_Mode:
             case SkXfermode::kDstOut_Mode:
             case SkXfermode::kDstOver_Mode:
             case SkXfermode::kPlus_Mode:
                 return 0 == this->getAlpha();
             case SkXfermode::kDst_Mode:
                 return true;
             default:
                 break;
         }
     }
     return false;
 }
 
 void SkPaint::setBitfields(uint32_t bitfields) {
-    fBitfields = bitfields;
+    fParts.fBitfields = bitfields;
 }
 
 inline static unsigned popcount(uint8_t x) {
     // As in Hacker's delight, adapted for just 8 bits.
     x = (x & 0x55) + ((x >> 1) & 0x55);  // a b c d w x y z -> a+b c+d w+x y+z
     x = (x & 0x33) + ((x >> 2) & 0x33);  // a+b c+d w+x y+z -> a+b+c+d w+x+y+z
     x = (x & 0x0F) + ((x >> 4) & 0x0F);  // a+b+c+d w+x+y+z -> a+b+c+d+w+x+y+z
     return x;
 }
 
@@ skipping 71 matching lines @@
     }
 #ifdef SK_BUILD_FOR_ANDROID
     if (dirty & kPaintOptionsAndroid_DirtyBit) {
         SkPaintOptionsAndroid options;
         options.unflatten(buffer);
         paint->setPaintOptionsAndroid(options);
     }
 #endif
     SkASSERT(dirty == paint->fDirtyBits);
 }