Test font created from paint

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"
@@ skipping 52 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() {
+    fCachedFont  = NULL;
+
     fTypeface    = NULL;
     fPathEffect  = NULL;
     fShader      = NULL;
     fXfermode    = NULL;
     fMaskFilter  = NULL;
     fColorFilter = NULL;
     fRasterizer  = NULL;
     fLooper      = NULL;
     fImageFilter = NULL;
     fAnnotation  = NULL;
@@ skipping 24 matching lines @@
 
 SkPaint::SkPaint(const SkPaint& src) {
     // Diagnoistic. May remove later. See crbug.com/364224
     if (NULL == &src) {
         sk_throw();
     }
 
 #define COPY(field) field = src.field
 #define REF_COPY(field) field = SkSafeRef(src.field)
 
+    REF_COPY(fCachedFont);
+
     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);
@@ skipping 10 matching lines @@
 #ifdef SK_BUILD_FOR_ANDROID
     new (&fPaintOptionsAndroid) SkPaintOptionsAndroid(src.fPaintOptionsAndroid);
     COPY(fGenerationID);
 #endif
 
 #undef COPY
 #undef REF_COPY
 }
 
 SkPaint::~SkPaint() {
+    SkSafeUnref(fCachedFont);
     SkSafeUnref(fTypeface);
     SkSafeUnref(fPathEffect);
     SkSafeUnref(fShader);
     SkSafeUnref(fXfermode);
     SkSafeUnref(fMaskFilter);
     SkSafeUnref(fColorFilter);
     SkSafeUnref(fRasterizer);
     SkSafeUnref(fLooper);
     SkSafeUnref(fImageFilter);
     SkSafeUnref(fAnnotation);
 }
 
 SkPaint& SkPaint::operator=(const SkPaint& src) {
     if (this == &src) {
         return *this;
     }
 
 #define COPY(field) field = src.field
 #define REF_COPY(field) SkSafeUnref(field); field = SkSafeRef(src.field)
 
     SkASSERT(&src);
 
+    REF_COPY(fCachedFont);
+
     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);
@@ skipping 81 matching lines @@
     }
 }
 #endif
 
 void SkPaint::setFilterLevel(FilterLevel level) {
     GEN_ID_INC_EVAL((unsigned) level != fFilterLevel);
     fFilterLevel = level;
 }
 
 void SkPaint::setHinting(Hinting hintingLevel) {
+    this->dirtyCachedFont(hintingLevel != fHinting);
     GEN_ID_INC_EVAL((unsigned) hintingLevel != fHinting);
     fHinting = hintingLevel;
 }
 
 void SkPaint::setFlags(uint32_t flags) {
+    this->dirtyCachedFont(fFlags != flags);
     GEN_ID_INC_EVAL(fFlags != flags);
     fFlags = flags;
 }
 
 void SkPaint::setAntiAlias(bool doAA) {
     this->setFlags(SkSetClearMask(fFlags, doAA, kAntiAlias_Flag));
 }
 
 void SkPaint::setDither(bool doDither) {
     this->setFlags(SkSetClearMask(fFlags, doDither, kDither_Flag));
@@ skipping 123 matching lines @@
         fTextAlign = SkToU8(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) {
+        this->dirtyCachedFont(ts != fTextSize);
         GEN_ID_INC_EVAL(ts != fTextSize);
         fTextSize = 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) {
+    this->dirtyCachedFont(scaleX != fTextScaleX);
     GEN_ID_INC_EVAL(scaleX != fTextScaleX);
     fTextScaleX = scaleX;
     fDirtyBits |= kTextScaleX_DirtyBit;
 }
 
 void SkPaint::setTextSkewX(SkScalar skewX) {
+    this->dirtyCachedFont(skewX != fTextSkewX);
     GEN_ID_INC_EVAL(skewX != fTextSkewX);
     fTextSkewX = skewX;
     fDirtyBits |= kTextSkewX_DirtyBit;
 }
 
 void SkPaint::setTextEncoding(TextEncoding encoding) {
     if ((unsigned)encoding <= kGlyphID_TextEncoding) {
         GEN_ID_INC_EVAL((unsigned)encoding != fTextEncoding);
         fTextEncoding = 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);
+SkTypeface* SkPaint::setTypeface(SkTypeface* typeface) {
+    this->dirtyCachedFont(typeface != fTypeface);
+    SkRefCnt_SafeAssign(fTypeface, typeface);
     GEN_ID_INC;
-    fDirtyBits = set_mask(fDirtyBits, kTypeface_DirtyBit, font != NULL);
-    return font;
+    fDirtyBits = set_mask(fDirtyBits, kTypeface_DirtyBit, typeface != NULL);
+    return typeface;
 }
 
 SkRasterizer* SkPaint::setRasterizer(SkRasterizer* r) {
     SkRefCnt_SafeAssign(fRasterizer, r);
     GEN_ID_INC;
     fDirtyBits = set_mask(fDirtyBits, kRasterizer_DirtyBit, r != NULL);
     return r;
 }
 
 SkDrawLooper* SkPaint::setLooper(SkDrawLooper* looper) {
@@ skipping 2261 matching lines @@
     }
 #ifdef SK_BUILD_FOR_ANDROID
     if (dirty & kPaintOptionsAndroid_DirtyBit) {
         SkPaintOptionsAndroid options;
         options.unflatten(buffer);
         paint->setPaintOptionsAndroid(options);
     }
 #endif
     SkASSERT(dirty == paint->fDirtyBits);
 }