Bisect Mac performance regression.

src/ports/SkFontHost_mac.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.
  */
 
 #ifdef SK_BUILD_FOR_MAC
 #import <ApplicationServices/ApplicationServices.h>
@@ skipping 333 matching lines @@
     }
 };
 
 Offscreen::Offscreen() : fRGBSpace(NULL), fCG(NULL),
                          fDoAA(false), fDoLCD(false) {
     fSize.set(0, 0);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static bool find_dict_traits(CFDictionaryRef dict, CTFontSymbolicTraits* traits) {
-    CFNumberRef num;
-    return CFDictionaryGetValueIfPresent(dict, kCTFontSymbolicTrait, (const void**)&num)
-    && CFNumberIsFloatType(num)
-    && CFNumberGetValue(num, kCFNumberSInt32Type, traits);
-}
-
 static bool find_dict_float(CFDictionaryRef dict, CFStringRef name, float* value) {
     CFNumberRef num;
     return CFDictionaryGetValueIfPresent(dict, name, (const void**)&num)
     && CFNumberIsFloatType(num)
     && CFNumberGetValue(num, kCFNumberFloatType, value);
 }
 
 static int unit_weight_to_fontstyle(float unit) {
     float value;
     if (unit < 0) {
         value = 100 + (1 + unit) * 300;
     } else {
         value = 400 + unit * 500;
     }
     return sk_float_round2int(value);
 }
 
 static int unit_width_to_fontstyle(float unit) {
     float value;
     if (unit < 0) {
         value = 1 + (1 + unit) * 4;
     } else {
         value = 5 + unit * 4;
     }
     return sk_float_round2int(value);
 }
 
-static SkFontStyle fontstyle_from_descriptor(CTFontDescriptorRef desc, bool* isFixedPitch) {
+static SkFontStyle fontstyle_from_descriptor(CTFontDescriptorRef desc) {
     AutoCFRelease<CFDictionaryRef> dict(
             (CFDictionaryRef)CTFontDescriptorCopyAttribute(desc, kCTFontTraitsAttribute));
     if (NULL == dict.get()) {
         return SkFontStyle();
     }
 
-    CTFontSymbolicTraits traits;
-    if (!find_dict_traits(dict, &traits)) {
-        traits = 0;
-    }
-    if (isFixedPitch) {
-        *isFixedPitch = SkToBool(traits & kCTFontMonoSpaceTrait);
-    }
-
     float weight, width, slant;
     if (!find_dict_float(dict, kCTFontWeightTrait, &weight)) {
-        weight = (traits & kCTFontBoldTrait) ? 0.5f : 0;
+        weight = 0;
     }
     if (!find_dict_float(dict, kCTFontWidthTrait, &width)) {
         width = 0;
     }
     if (!find_dict_float(dict, kCTFontSlantTrait, &slant)) {
-        slant = (traits & kCTFontItalicTrait) ? 0.5f : 0;
+        slant = 0;
     }
 
     return SkFontStyle(unit_weight_to_fontstyle(weight),
                        unit_width_to_fontstyle(width),
                        slant ? SkFontStyle::kItalic_Slant
                        : SkFontStyle::kUpright_Slant);
 }
 
+static SkTypeface::Style computeStyleBits(CTFontRef font, bool* isFixedPitch) {
+    unsigned style = SkTypeface::kNormal;
+    CTFontSymbolicTraits traits = CTFontGetSymbolicTraits(font);
+
+    if (traits & kCTFontBoldTrait) {
+        style |= SkTypeface::kBold;
+    }
+    if (traits & kCTFontItalicTrait) {
+        style |= SkTypeface::kItalic;
+    }
+    if (isFixedPitch) {
+        *isFixedPitch = (traits & kCTFontMonoSpaceTrait) != 0;
+    }
+    return (SkTypeface::Style)style;
+}
+
 static SkFontID CTFontRef_to_SkFontID(CTFontRef fontRef) {
     SkFontID id = 0;
 // CTFontGetPlatformFont and ATSFontRef are not supported on iOS, so we have to
 // bracket this to be Mac only.
 #ifdef SK_BUILD_FOR_MAC
     ATSFontRef ats = CTFontGetPlatformFont(fontRef, NULL);
     id = (SkFontID)ats;
     if (id != 0) {
         id &= 0x3FFFFFFF; // make top two bits 00
         return id;
@@ skipping 54 matching lines @@
 
 private:
     bool fIsLocalStream;
 
     typedef SkTypeface INHERITED;
 };
 
 static SkTypeface* NewFromFontRef(CTFontRef fontRef, const char name[], bool isLocalStream) {
     SkASSERT(fontRef);
     bool isFixedPitch;
-    AutoCFRelease<CTFontDescriptorRef> desc(CTFontCopyFontDescriptor(fontRef));
-    SkFontStyle style = fontstyle_from_descriptor(desc, &isFixedPitch);
+    SkFontStyle style = SkFontStyle(computeStyleBits(fontRef, &isFixedPitch));
     SkFontID fontID = CTFontRef_to_SkFontID(fontRef);
 
     return new SkTypeface_Mac(style, fontID, isFixedPitch, fontRef, name, isLocalStream);
 }
 
 static SkTypeface* NewFromName(const char familyName[], const SkFontStyle& theStyle) {
     CTFontRef ctFont = NULL;
 
     CTFontSymbolicTraits ctFontTraits = 0;
     if (theStyle.weight() >= SkFontStyle::kBold_Weight) {
@@ skipping 1509 matching lines @@
     return sqr(a.weight() - b.weight()) +
            sqr((a.width() - b.width()) * 100) +
            sqr((a.isItalic() != b.isItalic()) * 900);
 }
 
 static SkTypeface* createFromDesc(CFStringRef cfFamilyName, CTFontDescriptorRef desc) {
     NameStyle cacheRequest;
     SkString skFamilyName;
     CFStringToSkString(cfFamilyName, &skFamilyName);
     cacheRequest.fName = skFamilyName.c_str();
-    cacheRequest.fStyle = fontstyle_from_descriptor(desc, NULL);
+    cacheRequest.fStyle = fontstyle_from_descriptor(desc);
 
     SkTypeface* face = SkTypefaceCache::FindByProcAndRef(find_by_NameStyle, &cacheRequest);
     if (face) {
         return face;
     }
 
     AutoCFRelease<CFDictionaryRef> fontFamilyNameDictionary(
         CFDictionaryCreate(kCFAllocatorDefault,
                            (const void**)&kCTFontFamilyNameAttribute, (const void**)&cfFamilyName,
                            1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
     AutoCFRelease<CTFontDescriptorRef> fontDescriptor(
         CTFontDescriptorCreateWithAttributes(fontFamilyNameDictionary));
     AutoCFRelease<CTFontRef> ctNamed(CTFontCreateWithFontDescriptor(fontDescriptor, 0, NULL));
     CTFontRef ctFont = CTFontCreateCopyWithAttributes(ctNamed, 1, NULL, desc);
     if (NULL == ctFont) {
         return NULL;
     }
 
     bool isFixedPitch;
-    AutoCFRelease<CTFontDescriptorRef> ctFontDesc(CTFontCopyFontDescriptor(ctFont));
-    (void)fontstyle_from_descriptor(ctFontDesc, &isFixedPitch);
+    (void)computeStyleBits(ctFont, &isFixedPitch);
     SkFontID fontID = CTFontRef_to_SkFontID(ctFont);
 
     face = SkNEW_ARGS(SkTypeface_Mac, (cacheRequest.fStyle, fontID, isFixedPitch,
                                        ctFont, skFamilyName.c_str(), false));
     SkTypefaceCache::Add(face, face->fontStyle());
     return face;
 }
 
 class SkFontStyleSet_Mac : public SkFontStyleSet {
 public:
@@ skipping 14 matching lines @@
     }
 
     virtual int count() SK_OVERRIDE {
         return fCount;
     }
 
     virtual void getStyle(int index, SkFontStyle* style, SkString* name) SK_OVERRIDE {
         SkASSERT((unsigned)index < (unsigned)fCount);
         CTFontDescriptorRef desc = (CTFontDescriptorRef)CFArrayGetValueAtIndex(fArray, index);
         if (style) {
-            *style = fontstyle_from_descriptor(desc, NULL);
+            *style = fontstyle_from_descriptor(desc);
         }
         if (name) {
             if (!find_desc_str(desc, kCTFontStyleNameAttribute, name)) {
                 name->reset();
             }
         }
     }
 
     virtual SkTypeface* createTypeface(int index) SK_OVERRIDE {
         SkASSERT((unsigned)index < (unsigned)CFArrayGetCount(fArray));
@@ skipping 13 matching lines @@
     CFArrayRef  fArray;
     CFStringRef fFamilyName;
     int         fCount;
 
     CTFontDescriptorRef findMatchingDesc(const SkFontStyle& pattern) const {
         int bestMetric = SK_MaxS32;
         CTFontDescriptorRef bestDesc = NULL;
 
         for (int i = 0; i < fCount; ++i) {
             CTFontDescriptorRef desc = (CTFontDescriptorRef)CFArrayGetValueAtIndex(fArray, i);
-            int metric = compute_metric(pattern, fontstyle_from_descriptor(desc, NULL));
+            int metric = compute_metric(pattern, fontstyle_from_descriptor(desc));
             if (0 == metric) {
                 return desc;
             }
             if (metric < bestMetric) {
                 bestMetric = metric;
                 bestDesc = desc;
             }
         }
         SkASSERT(bestDesc);
         return bestDesc;
@@ skipping 116 matching lines @@
         }
         return face;
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgr_Mac);
 }