Use upcoming CTFont hb_face constructor

third_party/harfbuzz-ng/src/hb-coretext.cc

 /*
  * Copyright © 2012,2013  Mozilla Foundation.
  * Copyright © 2012,2013  Google, Inc.
+ * Copyright © 2016  Ebrahim Byagowi
  *
  *  This is part of HarfBuzz, a text shaping library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
  * software and its documentation for any purpose, provided that the
  * above copyright notice and the following two paragraphs appear in
  * all copies of this software.
  *
  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
@@ skipping 26 matching lines @@
 static void
 release_table_data (void *user_data)
 {
   CFDataRef cf_data = reinterpret_cast<CFDataRef> (user_data);
   CFRelease(cf_data);
 }
 
 static hb_blob_t *
 reference_table  (hb_face_t *face HB_UNUSED, hb_tag_t tag, void *user_data)
 {
-  CGFontRef cg_font = reinterpret_cast<CGFontRef> (user_data);
-  CFDataRef cf_data = CGFontCopyTableForTag (cg_font, tag);
+  CTFontRef ct_font = reinterpret_cast<CTFontRef> (user_data);
+  CFDataRef cf_data = CTFontCopyTable (ct_font, tag, kCTFontTableOptionNoOptions);
   if (unlikely (!cf_data))
     return NULL;
 
   const char *data = reinterpret_cast<const char*> (CFDataGetBytePtr (cf_data));
   const size_t length = CFDataGetLength (cf_data);
   if (!data || !length)
     return NULL;
 
   return hb_blob_create (data, length, HB_MEMORY_MODE_READONLY,
                          reinterpret_cast<void *> (const_cast<__CFData *> (cf_data)),
                          release_table_data);
 }
 
+static void
+hb_face_ct_font_destroyer (void *user_data)
+{
+  CTFontRef ct_font = reinterpret_cast<CTFontRef> (user_data);
+  CFRelease (ct_font);
+}
+
+/*
+ * Since: 0.9.2
+ */
 hb_face_t *
 hb_coretext_face_create (CGFontRef cg_font)
 {
-  return hb_face_create_for_tables (reference_table, CGFontRetain (cg_font), (hb_destroy_func_t) CGFontRelease);
+  return hb_face_create_for_tables (reference_table,
+                                    (void*) CTFontCreateWithGraphicsFont (cg_font, 36., 0, 0),
+                                    hb_face_ct_font_destroyer);
+
+}
+
+/*
+ * Since: 1.3.4
+ */
+hb_face_t *
+hb_coretext_face_create_from_ct_font (CTFontRef ct_font)
+{
+  return hb_face_create_for_tables (reference_table,
+                                    (void*) CFRetain (ct_font),
+                                    hb_face_ct_font_destroyer);
 }
 
 
 HB_SHAPER_DATA_ENSURE_DECLARE(coretext, face)
 HB_SHAPER_DATA_ENSURE_DECLARE(coretext, font)
 
 
 /*
  * shaper face data
  */
@@ skipping 14 matching lines @@
                                                    1,
                                                    &kCFTypeDictionaryKeyCallBacks,
                                                    &kCFTypeDictionaryValueCallBacks);
   CFRelease (cascade_list);
 
   CTFontDescriptorRef font_desc = CTFontDescriptorCreateWithAttributes (attributes);
   CFRelease (attributes);
   return font_desc;
 }
 
-static void
-release_data (void *info, const void *data, size_t size)
+static CTFontRef
+create_ct_font (CTFontDescriptorRef ct_font_descriptor, CGFloat font_size)
 {
-  assert (hb_blob_get_length ((hb_blob_t *) info) == size &&
-          hb_blob_get_data ((hb_blob_t *) info, NULL) == data);
-
-  hb_blob_destroy ((hb_blob_t *) info);
-}
-
-static CGFontRef
-create_cg_font (hb_face_t *face)
-{
-  CGFontRef cg_font = NULL;
-  if (face->destroy == (hb_destroy_func_t) CGFontRelease)
-  {
-    cg_font = CGFontRetain ((CGFontRef) face->user_data);
-  }
-  else
-  {
-    hb_blob_t *blob = hb_face_reference_blob (face);
-    unsigned int blob_length;
-    const char *blob_data = hb_blob_get_data (blob, &blob_length);
-    if (unlikely (!blob_length))
-      DEBUG_MSG (CORETEXT, face, "Face has empty blob");
-
-    CGDataProviderRef provider = CGDataProviderCreateWithData (blob, blob_data, blob_length, &release_data);
-    if (likely (provider))
-    {
-      cg_font = CGFontCreateWithDataProvider (provider);
-      if (unlikely (!cg_font))
-        DEBUG_MSG (CORETEXT, face, "Face CGFontCreateWithDataProvider() failed");
-      CGDataProviderRelease (provider);
-    }
-  }
-  return cg_font;
-}
-
-static CTFontRef
-create_ct_font (CGFontRef cg_font, CGFloat font_size)
-{
-  CTFontRef ct_font = CTFontCreateWithGraphicsFont (cg_font, font_size, NULL, NULL);
+  CTFontRef ct_font = CTFontCreateWithFontDescriptor (ct_font_descriptor, font_size, NULL);
   if (unlikely (!ct_font)) {
-    DEBUG_MSG (CORETEXT, cg_font, "Font CTFontCreateWithGraphicsFont() failed");
+    DEBUG_MSG (CORETEXT, ct_font_descriptor, "Font CTFontCreateWithFontDescriptor() failed");
     return NULL;
   }
 
   /* crbug.com/576941 and crbug.com/625902 and the investigation in the latter
    * bug indicate that the cascade list reconfiguration occasionally causes
    * crashes in CoreText on OS X 10.9, thus let's skip this step on older
    * operating system versions. Except for the emoji font, where _not_
    * reconfiguring the cascade list causes CoreText crashes. For details, see
    * crbug.com/549610 */
-  if (&CTGetCoreTextVersion != NULL && CTGetCoreTextVersion() < kCTVersionNumber10_10) {
+  // 0x00070000 stands for "kCTVersionNumber10_10", see CoreText.h
+  if (&CTGetCoreTextVersion != NULL && CTGetCoreTextVersion() < 0x00070000) {
     CFStringRef fontName = CTFontCopyPostScriptName (ct_font);
     bool isEmojiFont = CFStringCompare (fontName, CFSTR("AppleColorEmoji"), 0) == kCFCompareEqualTo;
     CFRelease (fontName);
     if (!isEmojiFont)
       return ct_font;
   }
 
   CFURLRef original_url = (CFURLRef)CTFontCopyAttribute(ct_font, kCTFontURLAttribute);
 
   /* Create font copy with cascade list that has LastResort first; this speeds up CoreText
@@ skipping 29 matching lines @@
     else
       DEBUG_MSG (CORETEXT, ct_font, "Font copy with empty cascade list failed");
   }
 
   if (original_url)
     CFRelease (original_url);
   return ct_font;
 }
 
 struct hb_coretext_shaper_face_data_t {
-  CGFontRef cg_font;
   CTFontRef ct_font;
+  hb_blob_t *blob;
 };
 
 hb_coretext_shaper_face_data_t *
 _hb_coretext_shaper_face_data_create (hb_face_t *face)
 {
   hb_coretext_shaper_face_data_t *data = (hb_coretext_shaper_face_data_t *) calloc (1, sizeof (hb_coretext_shaper_face_data_t));
   if (unlikely (!data))
     return NULL;
 
-  data->cg_font = create_cg_font (face);
-  if (unlikely (!data->cg_font))
+  if (face->destroy == hb_face_ct_font_destroyer)
   {
-    DEBUG_MSG (CORETEXT, face, "CGFont creation failed..");
+    data->ct_font = reinterpret_cast<CTFontRef> (CFRetain (face->user_data));
+    return data;
+  }
+
+  data->blob = hb_face_reference_blob (face);
+  unsigned int blob_length;
+  const char *blob_data = hb_blob_get_data (data->blob, &blob_length);
+  if (unlikely (!blob_length))
+  {
+    DEBUG_MSG (CORETEXT, face, "Face has empty blob");
     free (data);
     return NULL;
   }
+
+  CFDataRef cf_data = CFDataCreateWithBytesNoCopy (kCFAllocatorDefault,
+                                                   reinterpret_cast<const UInt8*> (blob_data),
+                                                   blob_length,
+                                                   kCFAllocatorNull);
+  if (unlikely (!cf_data))
+  {
+    DEBUG_MSG (CORETEXT, face, "CFDataRef creation failed.");
+    free (data);
+    return NULL;
+  }
+
+  CTFontDescriptorRef ct_font_descriptor = CTFontManagerCreateFontDescriptorFromData (cf_data);
+  if (unlikely (!ct_font_descriptor))
+  {
+    DEBUG_MSG (CORETEXT, face, "CTFontDescriptorRef creation failed.");
+    CFRelease (cf_data);
+    free (data);
+    return NULL;
+  }
 
   /* We use 36pt size instead of UPEM, because CoreText implements the 'trak' table,
    * which can make the font too tight at large sizes.  36pt should be a good semi-neutral
    * size.
    *
    * Since we always create CTFont at a fixed size, our CTFont lives in face_data
    * instead of font_data.  Which is good, because when people change scale on
    * hb_font_t, we won't need to update our CTFont. */
-  data->ct_font = create_ct_font (data->cg_font, 36.);
+  data->ct_font = create_ct_font (ct_font_descriptor, 36.);
   if (unlikely (!data->ct_font))
   {
     DEBUG_MSG (CORETEXT, face, "CTFont creation failed.");
-    CFRelease (data->cg_font);
+    CFRelease (ct_font_descriptor);
+    CFRelease (cf_data);
+    hb_blob_destroy (data->blob);
     free (data);
     return NULL;
   }
 
+  CFRelease (ct_font_descriptor);
+  CFRelease (cf_data);
+
   return data;
 }
 
 void
 _hb_coretext_shaper_face_data_destroy (hb_coretext_shaper_face_data_t *data)
 {
-  CFRelease (data->ct_font);
-  CFRelease (data->cg_font);
+  if (data->ct_font)
+    CFRelease (data->ct_font);
+  if (data->blob)
+    hb_blob_destroy (data->blob);
   free (data);
 }
 
 /*
  * Since: 0.9.10
  */
 CGFontRef
 hb_coretext_face_get_cg_font (hb_face_t *face)
 {
   if (unlikely (!hb_coretext_shaper_face_data_ensure (face))) return NULL;
   hb_coretext_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
-  return face_data->cg_font;
+  return CTFontCopyGraphicsFont (face_data->ct_font, NULL);
 }
 
 
 /*
  * shaper font data
  */
 
 struct hb_coretext_shaper_font_data_t {};
 
 hb_coretext_shaper_font_data_t *
@@ skipping 20 matching lines @@
                                              unsigned int        num_user_features HB_UNUSED)
 {
   return (hb_coretext_shaper_shape_plan_data_t *) HB_SHAPER_DATA_SUCCEEDED;
 }
 
 void
 _hb_coretext_shaper_shape_plan_data_destroy (hb_coretext_shaper_shape_plan_data_t *data HB_UNUSED)
 {
 }
 
+/*
+ * Since: 0.9.2
+ */
 CTFontRef
 hb_coretext_font_get_ct_font (hb_font_t *font)
 {
   hb_face_t *face = font->face;
   if (unlikely (!hb_coretext_shaper_face_data_ensure (face))) return NULL;
   hb_coretext_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
   return face_data->ct_font;
 }
 
 
@@ skipping 473 matching lines @@
 
     /* Adjust scratch, pchars, and log_cluster arrays.  This is ugly, but really the
      * cleanest way to do without completely restructuring the rest of this shaper. */
     scratch = buffer->get_scratch_buffer (&scratch_size);
     pchars = reinterpret_cast<UniChar *> (((char *) scratch + ((char *) pchars - (char *) old_scratch)));
     log_clusters = reinterpret_cast<unsigned int *> (((char *) scratch + ((char *) log_clusters - (char *) old_scratch)));
     scratch += old_scratch_used;
     scratch_size -= old_scratch_used;
   }
   {
-    string_ref = CFStringCreateWithCharactersNoCopy (NULL,
+    string_ref = CFStringCreateWithCharactersNoCopy (kCFAllocatorDefault,
                                                      pchars, chars_len,
                                                      kCFAllocatorNull);
     if (unlikely (!string_ref))
       FAIL ("CFStringCreateWithCharactersNoCopy failed");
 
     /* Create an attributed string, populate it, and create a line from it, then release attributed string. */
     {
       CFMutableAttributedStringRef attr_string = CFAttributedStringCreateMutable (kCFAllocatorDefault,
                                                                                   chars_len);
       if (unlikely (!attr_string))
@@ skipping 11 matching lines @@
  * The symbols was introduced in iOS 7.0.
  * At any rate, our fallback is safe and works fine. */
 #if MAC_OS_X_VERSION_MIN_REQUIRED < 1090
 #  define kCTLanguageAttributeName CFSTR ("NSLanguage")
 #endif
         CFStringRef lang = CFStringCreateWithCStringNoCopy (kCFAllocatorDefault,
                                                             hb_language_to_string (buffer->props.language),
                                                             kCFStringEncodingUTF8,
                                                             kCFAllocatorNull);
         if (unlikely (!lang))
+        {
+          CFRelease (attr_string);
           FAIL ("CFStringCreateWithCStringNoCopy failed");
+        }
         CFAttributedStringSetAttribute (attr_string, CFRangeMake (0, chars_len),
                                         kCTLanguageAttributeName, lang);
         CFRelease (lang);
       }
       CFAttributedStringSetAttribute (attr_string, CFRangeMake (0, chars_len),
                                       kCTFontAttributeName, face_data->ct_font);
 
       if (num_features)
       {
         unsigned int start = 0;
@@ skipping 23 matching lines @@
 
       int level = HB_DIRECTION_IS_FORWARD (buffer->props.direction) ? 0 : 1;
       CFNumberRef level_number = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &level);
       CFDictionaryRef options = CFDictionaryCreate (kCFAllocatorDefault,
                                                     (const void **) &kCTTypesetterOptionForcedEmbeddingLevel,
                                                     (const void **) &level_number,
                                                     1,
                                                     &kCFTypeDictionaryKeyCallBacks,
                                                     &kCFTypeDictionaryValueCallBacks);
       if (unlikely (!options))
+      {
+        CFRelease (attr_string);
         FAIL ("CFDictionaryCreate failed");
+      }
 
       CTTypesetterRef typesetter = CTTypesetterCreateWithAttributedStringAndOptions (attr_string, options);
       CFRelease (options);
       CFRelease (attr_string);
       if (unlikely (!typesetter))
         FAIL ("CTTypesetterCreateWithAttributedStringAndOptions failed");
 
       line = CTTypesetterCreateLine (typesetter, CFRangeMake(0, 0));
       CFRelease (typesetter);
       if (unlikely (!line))
@@ skipping 69 matching lines @@
          */
         bool matched = false;
         for (unsigned int i = 0; i < range_records.len; i++)
           if (range_records[i].font && CFEqual (run_ct_font, range_records[i].font))
           {
             matched = true;
             break;
           }
         if (!matched)
         {
-          CGFontRef run_cg_font = CTFontCopyGraphicsFont (run_ct_font, 0);
-          if (run_cg_font)
-          {
-            matched = CFEqual (run_cg_font, face_data->cg_font);
-            CFRelease (run_cg_font);
-          }
+          matched = CFEqual (run_ct_font, face_data->ct_font);
         }
         if (!matched)
         {
           CFStringRef font_ps_name = CTFontCopyName (face_data->ct_font, kCTFontPostScriptNameKey);
           CFStringRef run_ps_name = CTFontCopyName (run_ct_font, kCTFontPostScriptNameKey);
           CFComparisonResult result = CFStringCompare (run_ps_name, font_ps_name, 0);
           CFRelease (run_ps_name);
           CFRelease (font_ps_name);
           if (result == kCFCompareEqualTo)
             matched = true;
@@ skipping 321 matching lines @@
 
 hb_bool_t
 _hb_coretext_aat_shape (hb_shape_plan_t    *shape_plan,
                         hb_font_t          *font,
                         hb_buffer_t        *buffer,
                         const hb_feature_t *features,
                         unsigned int        num_features)
 {
   return _hb_coretext_shape (shape_plan, font, buffer, features, num_features);
 }