Use FreeType for OpenType Variations on CoreText < 10.12

third_party/WebKit/Source/platform/fonts/shaping/HarfBuzzFace.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 289 matching lines @@
         harf_buzz_skia_font_funcs, HarfBuzzGetGlyphVerticalAdvance, 0, 0);
     hb_font_funcs_set_glyph_v_origin_func(harf_buzz_skia_font_funcs,
                                           HarfBuzzGetGlyphVerticalOrigin, 0, 0);
     hb_font_funcs_set_glyph_extents_func(harf_buzz_skia_font_funcs,
                                          HarfBuzzGetGlyphExtents, 0, 0);
     hb_font_funcs_make_immutable(harf_buzz_skia_font_funcs);
   }
   return harf_buzz_skia_font_funcs;
 }
 
-#if !OS(MACOSX)
 static hb_blob_t* HarfBuzzSkiaGetTable(hb_face_t* face,
                                        hb_tag_t tag,
                                        void* user_data) {
   SkTypeface* typeface = reinterpret_cast<SkTypeface*>(user_data);
 
   const size_t table_size = typeface->getTableSize(tag);
   if (!table_size) {
     return nullptr;
   }
 
   char* buffer = reinterpret_cast<char*>(WTF::Partitions::FastMalloc(
       table_size, WTF_HEAP_PROFILER_TYPE_NAME(HarfBuzzFontData)));
   if (!buffer)
     return nullptr;
   size_t actual_size = typeface->getTableData(tag, 0, table_size, buffer);
   if (table_size != actual_size) {
     WTF::Partitions::FastFree(buffer);
     return nullptr;
   }
   return hb_blob_create(const_cast<char*>(buffer), table_size,
                         HB_MEMORY_MODE_WRITABLE, buffer,
                         WTF::Partitions::FastFree);
 }
-#endif
 
-#if !OS(MACOSX)
 static void DeleteTypefaceStream(void* stream_asset_ptr) {
   SkStreamAsset* stream_asset =
       reinterpret_cast<SkStreamAsset*>(stream_asset_ptr);
   delete stream_asset;
 }
-#endif
 
 hb_face_t* HarfBuzzFace::CreateFace() {
 #if OS(MACOSX)
-  hb_face_t* face = hb_coretext_face_create(platform_data_->CgFont());
-#else
+  // hb_face_t needs to be instantiated using the CoreText constructor for
+  // compatibility with AAT font, in which case HarfBuzz' CoreText backend is
+  // used. If we encounter a FreeType backed SkTypeface, for variable fonts on
+  // Mac OS < 10.12, follow the regular OpenType-only codepath below.
+  if (platform_data_->CgFont()) {
+    hb_face_t* face = hb_coretext_face_create(platform_data_->CgFont());
+    DCHECK(face);
+    return face;
+  }
+#endif
   hb_face_t* face = nullptr;
 
   DEFINE_STATIC_LOCAL(BooleanHistogram, zero_copy_success_histogram,
                       ("Blink.Fonts.HarfBuzzFaceZeroCopyAccess"));
   SkTypeface* typeface = platform_data_->Typeface();
   CHECK(typeface);
   int ttc_index = 0;
   SkStreamAsset* typeface_stream = typeface->openStream(&ttc_index);
   if (typeface_stream && typeface_stream->getMemoryBase()) {
     std::unique_ptr<hb_blob_t, void (*)(hb_blob_t*)> face_blob(
         hb_blob_create(
             reinterpret_cast<const char*>(typeface_stream->getMemoryBase()),
             typeface_stream->getLength(), HB_MEMORY_MODE_READONLY,
             typeface_stream, DeleteTypefaceStream),
         hb_blob_destroy);
     face = hb_face_create(face_blob.get(), ttc_index);
   }
 
   // Fallback to table copies if there is no in-memory access.
   if (!face) {
     face = hb_face_create_for_tables(HarfBuzzSkiaGetTable,
                                      platform_data_->Typeface(), 0);
     zero_copy_success_histogram.Count(false);
   } else {
     zero_copy_success_histogram.Count(true);
   }
-#endif
+
   DCHECK(face);
   return face;
 }
 
 PassRefPtr<HbFontCacheEntry> CreateHbFontCacheEntry(hb_face_t* face) {
   HbFontUniquePtr ot_font(hb_font_create(face));
   hb_ot_font_set_funcs(ot_font.get());
   // Creating a sub font means that non-available functions
   // are found from the parent.
   hb_font_t* unscaled_font = hb_font_create_sub_font(ot_font.get());
@@ skipping 36 matching lines @@
       hb_font_set_variations(
           unscaled_font_, reinterpret_cast<hb_variation_t*>(axis_values.data()),
           axis_values.size());
     }
   }
 
   return unscaled_font_;
 }
 
 }  // namespace blink