Avoid CTFontCreateCopyWithAttributes.

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.
  */
 
 #include "SkTypes.h"  // Keep this before any #ifdef ...
 
@@ skipping 722 matching lines @@
 
     // CT on (at least) 10.9 will size color glyphs down from the requested size, but not up.
     // As a result, it is necessary to know the actual device size and request that.
     SkVector scale;
     SkMatrix skTransform;
     fRec.computeMatrices(SkScalerContextRec::kVertical_PreMatrixScale, &scale, &skTransform,
                          nullptr, nullptr, &fFUnitMatrix);
     fTransform = MatrixToCGAffineTransform(skTransform);
     fInvTransform = CGAffineTransformInvert(fTransform);
 
-    AutoCFRelease<CTFontDescriptorRef> ctFontDesc;
-    if (fVertical) {
-        // Setting the vertical orientation here is required for vertical metrics on some versions.
-        AutoCFRelease<CFMutableDictionaryRef> cfAttributes(CFDictionaryCreateMutable(
-                kCFAllocatorDefault, 0,
-                &kCFTypeDictionaryKeyCallBacks,
-                &kCFTypeDictionaryValueCallBacks));
-        if (cfAttributes) {
-            CTFontOrientation ctOrientation = kCTFontVerticalOrientation;
-            AutoCFRelease<CFNumberRef> cfVertical(CFNumberCreate(
-                    kCFAllocatorDefault, kCFNumberSInt32Type, &ctOrientation));
-            CFDictionaryAddValue(cfAttributes, kCTFontOrientationAttribute, cfVertical);
-            ctFontDesc.reset(CTFontDescriptorCreateWithAttributes(cfAttributes));
-        }
+    // CTFontCreateCopyWithAttributes or CTFontCreateCopyWithSymbolicTraits cannot be used on 10.10
+    // as they appear to be buggy with respect to the default font. It is not possible to use
+    // descriptors with CTFontCreateWithFontDescriptor, since that does not work with non-system
+    // fonts. As a result, create the new fonts from the underlying CGFont.
+
+    AutoCFRelease<CTFontDescriptorRef> baseDescriptor;
+    AutoCFRelease<CGFontRef> baseCGFont(CTFontCopyGraphicsFont(ctFont, &baseDescriptor));
+
+    // Make a mutable copy of baseDescriptor attributes.
+    AutoCFRelease<CFMutableDictionaryRef> newAttributes;
+    if (nullptr == baseDescriptor) {
+        newAttributes.reset(CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+                                                      &kCFTypeDictionaryKeyCallBacks,
+                                                      &kCFTypeDictionaryValueCallBacks));
+    } else {
+        AutoCFRelease<CFDictionaryRef> baseAttributes(
+            CTFontDescriptorCopyAttributes(baseDescriptor));
+        newAttributes.reset(CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, baseAttributes));
     }
 
     // The transform contains everything except the requested text size.
     // Some properties, like 'trak', are based on the text size (before applying the matrix).
     CGFloat textSize = ScalarToCG(scale.y());
+    AutoCFRelease<CFNumberRef> cfTextSize(
+        CFNumberCreate(kCFAllocatorDefault, kCFNumberCGFloatType, &textSize));
+    CFDictionarySetValue(newAttributes, kCTFontSizeAttribute, cfTextSize);
 
-    fCTFont.reset(CTFontCreateCopyWithAttributes(ctFont, textSize, &fTransform, ctFontDesc));
+    // First create the unrotated font at the right size.
+    CFDictionaryRemoveValue(newAttributes, kCTFontMatrixAttribute);
+
+    AutoCFRelease<CTFontDescriptorRef> unrotatedFontDescriptor(
+        CTFontDescriptorCreateWithAttributes(newAttributes));
+    fCTUnrotatedFont.reset(CTFontCreateWithGraphicsFont(baseCGFont, textSize, nullptr,

[erikchen, 2015/09/16 20:50:28]

nit: The textSize parameter here looks redundant with the attribute in line 767
- are they both necessary?

[bungeman-skia, 2015/09/17 16:26:06]

It does, doesn't it. On the other hand, under the hood they appear to set
different things. This is probably somewhat belt and suspenders, but I think
various versions treat these somewhat differently. For the time being, I'm going
to set them both because this seems to work and should work across versions.
(Almost all of the comments and around a third of the code in this file is to
work around issues in various versions of coretext/coregraphics, so I'm a bit
paranoid in general here.) Eventually (probably when 10.6 support is dropped)
I'm going to go through all of this file on supported versions and see what can
be ripped out.

+                                                        unrotatedFontDescriptor));
+
+    // Now create the fully transformed font.
+    if (fVertical) {
+        CTFontOrientation ctOrientation = kCTFontVerticalOrientation;
+        AutoCFRelease<CFNumberRef> cfVertical(
+            CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &ctOrientation));
+        CFDictionarySetValue(newAttributes, kCTFontOrientationAttribute, cfVertical);
+    }
+
+    AutoCFRelease<CFDataRef> cfMatrixData(CFDataCreate(
+        kCFAllocatorDefault, reinterpret_cast<const UInt8*>(&fTransform), sizeof(fTransform)));
+    CFDictionaryAddValue(newAttributes, kCTFontMatrixAttribute, cfMatrixData);
+
+    AutoCFRelease<CTFontDescriptorRef> newFontDescriptor(
+        CTFontDescriptorCreateWithAttributes(newAttributes));
+    fCTFont.reset(CTFontCreateWithGraphicsFont(baseCGFont, textSize, &fTransform,
+                                               newFontDescriptor));
+
     fCGFont.reset(CTFontCopyGraphicsFont(fCTFont, nullptr));
-    fCTUnrotatedFont.reset(CTFontCreateCopyWithAttributes(ctFont, textSize,
-                                                          &CGAffineTransformIdentity, nullptr));
 
     // The fUnitMatrix includes the text size (and em) as it is used to scale the raw font data.
     SkScalar emPerFUnit = SkScalarInvert(SkIntToScalar(CGFontGetUnitsPerEm(fCGFont)));
     fFUnitMatrix.preScale(emPerFUnit, -emPerFUnit);
 }
 
 /** This is an implementation of CTFontDrawGlyphs for 10.6; it was introduced in 10.7. */
 static void legacy_CTFontDrawGlyphs(CTFontRef, const CGGlyph glyphs[], const CGPoint points[],
                                     size_t count, CGContextRef cg) {
     CGContextShowGlyphsAtPositions(cg, glyphs, points, count);
@@ skipping 581 matching lines @@
                 break;
             case kY_SkAxisAlignment:
                 scaleX = SK_Scalar1; // want hinting in the X direction
                 break;
             default:
                 break;
         }
 
         CGAffineTransform xform = MatrixToCGAffineTransform(m, scaleX, scaleY);
         // need to release font when we're done
         font = CTFontCreateCopyWithAttributes(fCTFont, 1, &xform, nullptr);

[bungeman-skia, 2015/09/17 16:26:06]

Will need to fix this use.

     }
 
     CGGlyph cgGlyph = (CGGlyph)glyph.getGlyphID();
     AutoCFRelease<CGPathRef> cgPath(CTFontCreatePathForGlyph(font, cgGlyph, nullptr));
 
     path->reset();
     if (cgPath != nullptr) {
         CGPathApply(cgPath, path, SkScalerContext_Mac::CTPathElement);
     }
 
@@ skipping 175 matching lines @@
 }
 
 SkAdvancedTypefaceMetrics* SkTypeface_Mac::onGetAdvancedTypefaceMetrics(
         PerGlyphInfo perGlyphInfo,
         const uint32_t* glyphIDs,
         uint32_t glyphIDsCount) const {
 
     AUTO_CG_LOCK();
 
     CTFontRef originalCTFont = fFontRef.get();
     AutoCFRelease<CTFontRef> ctFont(CTFontCreateCopyWithAttributes(

[bungeman-skia, 2015/09/17 16:26:06]

And this use.

             originalCTFont, CTFontGetUnitsPerEm(originalCTFont), nullptr, nullptr));
     SkAdvancedTypefaceMetrics* info = new SkAdvancedTypefaceMetrics;
 
     {
         AutoCFRelease<CFStringRef> fontName(CTFontCopyPostScriptName(ctFont));
         if (fontName.get()) {
             CFStringToSkString(fontName, &info->fFontName);
         }
     }
 
@@ skipping 899 matching lines @@
                 face->ref();
             }
         }
         return face;
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() { return new SkFontMgr_Mac; }