summaryrefslogtreecommitdiffstats
path: root/gfx/2d/ScaledFontFontconfig.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /gfx/2d/ScaledFontFontconfig.cpp
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/2d/ScaledFontFontconfig.cpp')
-rw-r--r--gfx/2d/ScaledFontFontconfig.cpp550
1 files changed, 550 insertions, 0 deletions
diff --git a/gfx/2d/ScaledFontFontconfig.cpp b/gfx/2d/ScaledFontFontconfig.cpp
new file mode 100644
index 0000000000..e3025c1072
--- /dev/null
+++ b/gfx/2d/ScaledFontFontconfig.cpp
@@ -0,0 +1,550 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "ScaledFontFontconfig.h"
+#include "UnscaledFontFreeType.h"
+#include "Logging.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+
+#include "skia/include/ports/SkTypeface_cairo.h"
+#include "HelpersSkia.h"
+
+#include <fontconfig/fcfreetype.h>
+
+#include FT_LCD_FILTER_H
+#include FT_MULTIPLE_MASTERS_H
+
+namespace mozilla::gfx {
+
+ScaledFontFontconfig::ScaledFontFontconfig(
+ RefPtr<SharedFTFace>&& aFace, FcPattern* aPattern,
+ const RefPtr<UnscaledFont>& aUnscaledFont, Float aSize)
+ : ScaledFontBase(aUnscaledFont, aSize),
+ mFace(std::move(aFace)),
+ mInstanceData(aPattern) {}
+
+ScaledFontFontconfig::ScaledFontFontconfig(
+ RefPtr<SharedFTFace>&& aFace, const InstanceData& aInstanceData,
+ const RefPtr<UnscaledFont>& aUnscaledFont, Float aSize)
+ : ScaledFontBase(aUnscaledFont, aSize),
+ mFace(std::move(aFace)),
+ mInstanceData(aInstanceData) {}
+
+bool ScaledFontFontconfig::UseSubpixelPosition() const {
+ return !MOZ_UNLIKELY(
+ StaticPrefs::
+ gfx_text_subpixel_position_force_disabled_AtStartup()) &&
+ mInstanceData.mAntialias != AntialiasMode::NONE &&
+ FT_IS_SCALABLE(mFace->GetFace()) &&
+ (mInstanceData.mHinting == FontHinting::NONE ||
+ mInstanceData.mHinting == FontHinting::LIGHT ||
+ MOZ_UNLIKELY(
+ StaticPrefs::
+ gfx_text_subpixel_position_force_enabled_AtStartup()));
+}
+
+SkTypeface* ScaledFontFontconfig::CreateSkTypeface() {
+ SkPixelGeometry geo = mInstanceData.mFlags & InstanceData::SUBPIXEL_BGR
+ ? (mInstanceData.mFlags & InstanceData::LCD_VERTICAL
+ ? kBGR_V_SkPixelGeometry
+ : kBGR_H_SkPixelGeometry)
+ : (mInstanceData.mFlags & InstanceData::LCD_VERTICAL
+ ? kRGB_V_SkPixelGeometry
+ : kRGB_H_SkPixelGeometry);
+ return SkCreateTypefaceFromCairoFTFont(mFace->GetFace(), mFace.get(), geo,
+ mInstanceData.mLcdFilter);
+}
+
+void ScaledFontFontconfig::SetupSkFontDrawOptions(SkFont& aFont) {
+ aFont.setSubpixel(UseSubpixelPosition());
+
+ if (mInstanceData.mFlags & InstanceData::AUTOHINT) {
+ aFont.setForceAutoHinting(true);
+ }
+ if (mInstanceData.mFlags & InstanceData::EMBEDDED_BITMAP) {
+ aFont.setEmbeddedBitmaps(true);
+ }
+ if (mInstanceData.mFlags & InstanceData::EMBOLDEN) {
+ aFont.setEmbolden(true);
+ }
+
+ aFont.setHinting(GfxHintingToSkiaHinting(mInstanceData.mHinting));
+}
+
+bool ScaledFontFontconfig::MayUseBitmaps() {
+ return mInstanceData.mFlags & InstanceData::EMBEDDED_BITMAP &&
+ !FT_IS_SCALABLE(mFace->GetFace());
+}
+
+cairo_font_face_t* ScaledFontFontconfig::CreateCairoFontFace(
+ cairo_font_options_t* aFontOptions) {
+ int loadFlags;
+ unsigned int synthFlags;
+ mInstanceData.SetupFontOptions(aFontOptions, &loadFlags, &synthFlags);
+
+ return cairo_ft_font_face_create_for_ft_face(mFace->GetFace(), loadFlags,
+ synthFlags, mFace.get());
+}
+
+AntialiasMode ScaledFontFontconfig::GetDefaultAAMode() {
+ return mInstanceData.mAntialias;
+}
+
+bool FcPatternAllowsBitmaps(FcPattern* aPattern, bool aAntialias,
+ bool aHinting) {
+ if (!aAntialias) {
+ // Always allow bitmaps when antialiasing is disabled
+ return true;
+ }
+ FcBool bitmap;
+ if (FcPatternGetBool(aPattern, FC_EMBEDDED_BITMAP, 0, &bitmap) !=
+ FcResultMatch ||
+ !bitmap) {
+ // If bitmaps were explicitly disabled, then disallow them
+ return false;
+ }
+ if (aHinting) {
+ // If hinting is used and bitmaps were enabled, then allow them
+ return true;
+ }
+ // When hinting is disabled, then avoid loading bitmaps from outline
+ // fonts. However, emoji fonts may have no outlines while containing
+ // bitmaps intended to be scaled, so still allow those.
+ FcBool outline;
+ if (FcPatternGetBool(aPattern, FC_OUTLINE, 0, &outline) == FcResultMatch &&
+ outline) {
+ return false;
+ }
+ FcBool scalable;
+ if (FcPatternGetBool(aPattern, FC_SCALABLE, 0, &scalable) != FcResultMatch ||
+ !scalable) {
+ return false;
+ }
+ return true;
+}
+
+ScaledFontFontconfig::InstanceData::InstanceData(FcPattern* aPattern)
+ : mFlags(0),
+ mAntialias(AntialiasMode::NONE),
+ mHinting(FontHinting::NONE),
+ mLcdFilter(FT_LCD_FILTER_LEGACY) {
+ // Record relevant Fontconfig properties into instance data.
+ FcBool autohint;
+ if (FcPatternGetBool(aPattern, FC_AUTOHINT, 0, &autohint) == FcResultMatch &&
+ autohint) {
+ mFlags |= AUTOHINT;
+ }
+ FcBool embolden;
+ if (FcPatternGetBool(aPattern, FC_EMBOLDEN, 0, &embolden) == FcResultMatch &&
+ embolden) {
+ mFlags |= EMBOLDEN;
+ }
+
+ // For printer fonts, Cairo hint metrics and hinting will be disabled.
+ // For other fonts, allow hint metrics and hinting.
+ FcBool printing;
+ if (FcPatternGetBool(aPattern, "gfx.printing", 0, &printing) !=
+ FcResultMatch ||
+ !printing) {
+ mFlags |= HINT_METRICS;
+
+ FcBool hinting;
+ if (FcPatternGetBool(aPattern, FC_HINTING, 0, &hinting) != FcResultMatch ||
+ hinting) {
+ int hintstyle;
+ if (FcPatternGetInteger(aPattern, FC_HINT_STYLE, 0, &hintstyle) !=
+ FcResultMatch) {
+ hintstyle = FC_HINT_FULL;
+ }
+ switch (hintstyle) {
+ case FC_HINT_SLIGHT:
+ mHinting = FontHinting::LIGHT;
+ break;
+ case FC_HINT_MEDIUM:
+ mHinting = FontHinting::NORMAL;
+ break;
+ case FC_HINT_FULL:
+ mHinting = FontHinting::FULL;
+ break;
+ case FC_HINT_NONE:
+ default:
+ break;
+ }
+ }
+ }
+
+ FcBool antialias;
+ if (FcPatternGetBool(aPattern, FC_ANTIALIAS, 0, &antialias) ==
+ FcResultMatch &&
+ !antialias) {
+ // If AA is explicitly disabled, leave bitmaps enabled.
+ mFlags |= EMBEDDED_BITMAP;
+ } else {
+ mAntialias = AntialiasMode::GRAY;
+
+ // Otherwise, if AA is enabled, disable embedded bitmaps unless explicitly
+ // enabled.
+ if (FcPatternAllowsBitmaps(aPattern, true, mHinting != FontHinting::NONE)) {
+ mFlags |= EMBEDDED_BITMAP;
+ }
+
+ // Only record subpixel order and lcd filtering if antialiasing is enabled.
+ int rgba;
+ if (mFlags & HINT_METRICS &&
+ FcPatternGetInteger(aPattern, FC_RGBA, 0, &rgba) == FcResultMatch) {
+ switch (rgba) {
+ case FC_RGBA_RGB:
+ case FC_RGBA_BGR:
+ case FC_RGBA_VRGB:
+ case FC_RGBA_VBGR:
+ mAntialias = AntialiasMode::SUBPIXEL;
+ if (rgba == FC_RGBA_VRGB || rgba == FC_RGBA_VBGR) {
+ mFlags |= LCD_VERTICAL;
+ }
+ if (rgba == FC_RGBA_BGR || rgba == FC_RGBA_VBGR) {
+ mFlags |= SUBPIXEL_BGR;
+ }
+ break;
+ case FC_RGBA_NONE:
+ case FC_RGBA_UNKNOWN:
+ default:
+ break;
+ }
+ }
+
+ int filter;
+ if (mAntialias == AntialiasMode::SUBPIXEL &&
+ FcPatternGetInteger(aPattern, FC_LCD_FILTER, 0, &filter) ==
+ FcResultMatch) {
+ switch (filter) {
+ case FC_LCD_NONE:
+ mLcdFilter = FT_LCD_FILTER_NONE;
+ break;
+ case FC_LCD_DEFAULT:
+ mLcdFilter = FT_LCD_FILTER_DEFAULT;
+ break;
+ case FC_LCD_LIGHT:
+ mLcdFilter = FT_LCD_FILTER_LIGHT;
+ break;
+ case FC_LCD_LEGACY:
+ default:
+ break;
+ }
+ }
+ }
+}
+
+ScaledFontFontconfig::InstanceData::InstanceData(
+ const wr::FontInstanceOptions* aOptions,
+ const wr::FontInstancePlatformOptions* aPlatformOptions)
+ : mFlags(HINT_METRICS),
+ mAntialias(AntialiasMode::NONE),
+ mHinting(FontHinting::FULL),
+ mLcdFilter(FT_LCD_FILTER_LEGACY) {
+ if (aOptions) {
+ if (aOptions->flags & wr::FontInstanceFlags::FORCE_AUTOHINT) {
+ mFlags |= AUTOHINT;
+ }
+ if (aOptions->flags & wr::FontInstanceFlags::EMBEDDED_BITMAPS) {
+ mFlags |= EMBEDDED_BITMAP;
+ }
+ if (aOptions->flags & wr::FontInstanceFlags::SYNTHETIC_BOLD) {
+ mFlags |= EMBOLDEN;
+ }
+ if (aOptions->render_mode == wr::FontRenderMode::Subpixel) {
+ mAntialias = AntialiasMode::SUBPIXEL;
+ if (aOptions->flags & wr::FontInstanceFlags::SUBPIXEL_BGR) {
+ mFlags |= SUBPIXEL_BGR;
+ }
+ if (aOptions->flags & wr::FontInstanceFlags::LCD_VERTICAL) {
+ mFlags |= LCD_VERTICAL;
+ }
+ } else if (aOptions->render_mode != wr::FontRenderMode::Mono) {
+ mAntialias = AntialiasMode::GRAY;
+ }
+ }
+ if (aPlatformOptions) {
+ switch (aPlatformOptions->hinting) {
+ case wr::FontHinting::None:
+ mHinting = FontHinting::NONE;
+ break;
+ case wr::FontHinting::Light:
+ mHinting = FontHinting::LIGHT;
+ break;
+ case wr::FontHinting::Normal:
+ mHinting = FontHinting::NORMAL;
+ break;
+ default:
+ break;
+ }
+ switch (aPlatformOptions->lcd_filter) {
+ case wr::FontLCDFilter::None:
+ mLcdFilter = FT_LCD_FILTER_NONE;
+ break;
+ case wr::FontLCDFilter::Default:
+ mLcdFilter = FT_LCD_FILTER_DEFAULT;
+ break;
+ case wr::FontLCDFilter::Light:
+ mLcdFilter = FT_LCD_FILTER_LIGHT;
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+void ScaledFontFontconfig::InstanceData::SetupFontOptions(
+ cairo_font_options_t* aFontOptions, int* aOutLoadFlags,
+ unsigned int* aOutSynthFlags) const {
+ // For regular (non-printer) fonts, enable hint metrics as well as hinting
+ // and (possibly subpixel) antialiasing.
+ cairo_font_options_set_hint_metrics(
+ aFontOptions,
+ mFlags & HINT_METRICS ? CAIRO_HINT_METRICS_ON : CAIRO_HINT_METRICS_OFF);
+
+ cairo_hint_style_t hinting;
+ switch (mHinting) {
+ case FontHinting::NONE:
+ hinting = CAIRO_HINT_STYLE_NONE;
+ break;
+ case FontHinting::LIGHT:
+ hinting = CAIRO_HINT_STYLE_SLIGHT;
+ break;
+ case FontHinting::NORMAL:
+ hinting = CAIRO_HINT_STYLE_MEDIUM;
+ break;
+ case FontHinting::FULL:
+ hinting = CAIRO_HINT_STYLE_FULL;
+ break;
+ }
+ cairo_font_options_set_hint_style(aFontOptions, hinting);
+
+ switch (mAntialias) {
+ case AntialiasMode::NONE:
+ cairo_font_options_set_antialias(aFontOptions, CAIRO_ANTIALIAS_NONE);
+ break;
+ case AntialiasMode::GRAY:
+ default:
+ cairo_font_options_set_antialias(aFontOptions, CAIRO_ANTIALIAS_GRAY);
+ break;
+ case AntialiasMode::SUBPIXEL: {
+ cairo_font_options_set_antialias(aFontOptions, CAIRO_ANTIALIAS_SUBPIXEL);
+ cairo_font_options_set_subpixel_order(
+ aFontOptions,
+ mFlags & SUBPIXEL_BGR
+ ? (mFlags & LCD_VERTICAL ? CAIRO_SUBPIXEL_ORDER_VBGR
+ : CAIRO_SUBPIXEL_ORDER_BGR)
+ : (mFlags & LCD_VERTICAL ? CAIRO_SUBPIXEL_ORDER_VRGB
+ : CAIRO_SUBPIXEL_ORDER_RGB));
+ cairo_lcd_filter_t lcdFilter = CAIRO_LCD_FILTER_DEFAULT;
+ switch (mLcdFilter) {
+ case FT_LCD_FILTER_NONE:
+ lcdFilter = CAIRO_LCD_FILTER_NONE;
+ break;
+ case FT_LCD_FILTER_DEFAULT:
+ lcdFilter = CAIRO_LCD_FILTER_FIR5;
+ break;
+ case FT_LCD_FILTER_LIGHT:
+ lcdFilter = CAIRO_LCD_FILTER_FIR3;
+ break;
+ case FT_LCD_FILTER_LEGACY:
+ lcdFilter = CAIRO_LCD_FILTER_INTRA_PIXEL;
+ break;
+ }
+ cairo_font_options_set_lcd_filter(aFontOptions, lcdFilter);
+ break;
+ }
+ }
+
+ // Try to build a sane initial set of Cairo font options based on the
+ // Fontconfig pattern.
+ int loadFlags = FT_LOAD_DEFAULT;
+ unsigned int synthFlags = 0;
+
+ if (!(mFlags & EMBEDDED_BITMAP)) {
+ loadFlags |= FT_LOAD_NO_BITMAP;
+ }
+ if (mFlags & AUTOHINT) {
+ loadFlags |= FT_LOAD_FORCE_AUTOHINT;
+ }
+ if (mFlags & EMBOLDEN) {
+ synthFlags |= CAIRO_FT_SYNTHESIZE_BOLD;
+ }
+
+ *aOutLoadFlags = loadFlags;
+ *aOutSynthFlags = synthFlags;
+}
+
+bool ScaledFontFontconfig::GetFontInstanceData(FontInstanceDataOutput aCb,
+ void* aBaton) {
+ std::vector<FontVariation> variations;
+ if (HasVariationSettings()) {
+ UnscaledFontFreeType::GetVariationSettingsFromFace(&variations,
+ mFace->GetFace());
+ }
+
+ aCb(reinterpret_cast<uint8_t*>(&mInstanceData), sizeof(mInstanceData),
+ variations.data(), variations.size(), aBaton);
+ return true;
+}
+
+bool ScaledFontFontconfig::GetWRFontInstanceOptions(
+ Maybe<wr::FontInstanceOptions>* aOutOptions,
+ Maybe<wr::FontInstancePlatformOptions>* aOutPlatformOptions,
+ std::vector<FontVariation>* aOutVariations) {
+ wr::FontInstanceOptions options;
+ options.render_mode = wr::FontRenderMode::Alpha;
+ options.flags = wr::FontInstanceFlags{0};
+ if (UseSubpixelPosition()) {
+ options.flags |= wr::FontInstanceFlags::SUBPIXEL_POSITION;
+ }
+ options.bg_color = wr::ToColorU(DeviceColor());
+ options.synthetic_italics =
+ wr::DegreesToSyntheticItalics(GetSyntheticObliqueAngle());
+
+ wr::FontInstancePlatformOptions platformOptions;
+ platformOptions.lcd_filter = wr::FontLCDFilter::Legacy;
+ platformOptions.hinting = wr::FontHinting::Normal;
+
+ if (mInstanceData.mFlags & InstanceData::AUTOHINT) {
+ options.flags |= wr::FontInstanceFlags::FORCE_AUTOHINT;
+ }
+ if (mInstanceData.mFlags & InstanceData::EMBOLDEN) {
+ options.flags |= wr::FontInstanceFlags::SYNTHETIC_BOLD;
+ }
+ if (mInstanceData.mFlags & InstanceData::EMBEDDED_BITMAP) {
+ options.flags |= wr::FontInstanceFlags::EMBEDDED_BITMAPS;
+ }
+ if (mInstanceData.mAntialias != AntialiasMode::NONE) {
+ if (mInstanceData.mAntialias == AntialiasMode::SUBPIXEL) {
+ options.render_mode = wr::FontRenderMode::Subpixel;
+ platformOptions.hinting = wr::FontHinting::LCD;
+ if (mInstanceData.mFlags & InstanceData::LCD_VERTICAL) {
+ options.flags |= wr::FontInstanceFlags::LCD_VERTICAL;
+ }
+ if (mInstanceData.mFlags & InstanceData::SUBPIXEL_BGR) {
+ options.flags |= wr::FontInstanceFlags::SUBPIXEL_BGR;
+ }
+ }
+
+ switch (mInstanceData.mLcdFilter) {
+ case FT_LCD_FILTER_NONE:
+ platformOptions.lcd_filter = wr::FontLCDFilter::None;
+ break;
+ case FT_LCD_FILTER_DEFAULT:
+ platformOptions.lcd_filter = wr::FontLCDFilter::Default;
+ break;
+ case FT_LCD_FILTER_LIGHT:
+ platformOptions.lcd_filter = wr::FontLCDFilter::Light;
+ break;
+ case FT_LCD_FILTER_LEGACY:
+ default:
+ break;
+ }
+
+ switch (mInstanceData.mHinting) {
+ case FontHinting::NONE:
+ platformOptions.hinting = wr::FontHinting::None;
+ break;
+ case FontHinting::LIGHT:
+ platformOptions.hinting = wr::FontHinting::Light;
+ break;
+ case FontHinting::NORMAL:
+ platformOptions.hinting = wr::FontHinting::Normal;
+ break;
+ case FontHinting::FULL:
+ break;
+ }
+ } else {
+ options.render_mode = wr::FontRenderMode::Mono;
+
+ switch (mInstanceData.mHinting) {
+ case FontHinting::NONE:
+ platformOptions.hinting = wr::FontHinting::None;
+ break;
+ default:
+ platformOptions.hinting = wr::FontHinting::Mono;
+ break;
+ }
+ }
+
+ *aOutOptions = Some(options);
+ *aOutPlatformOptions = Some(platformOptions);
+
+ if (HasVariationSettings()) {
+ UnscaledFontFreeType::GetVariationSettingsFromFace(aOutVariations,
+ mFace->GetFace());
+ }
+
+ return true;
+}
+
+already_AddRefed<ScaledFont> UnscaledFontFontconfig::CreateScaledFont(
+ Float aSize, const uint8_t* aInstanceData, uint32_t aInstanceDataLength,
+ const FontVariation* aVariations, uint32_t aNumVariations) {
+ if (aInstanceDataLength < sizeof(ScaledFontFontconfig::InstanceData)) {
+ gfxWarning() << "Fontconfig scaled font instance data is truncated.";
+ return nullptr;
+ }
+ const ScaledFontFontconfig::InstanceData& instanceData =
+ *reinterpret_cast<const ScaledFontFontconfig::InstanceData*>(
+ aInstanceData);
+
+ RefPtr<SharedFTFace> face(InitFace());
+ if (!face) {
+ gfxWarning() << "Attempted to deserialize Fontconfig scaled font without "
+ "FreeType face";
+ return nullptr;
+ }
+
+ if (aNumVariations > 0 && face->GetData()) {
+ if (RefPtr<SharedFTFace> varFace = face->GetData()->CloneFace()) {
+ face = varFace;
+ }
+ }
+
+ // Only apply variations if we have an explicitly cloned face.
+ if (aNumVariations > 0 && face != GetFace()) {
+ ApplyVariationsToFace(aVariations, aNumVariations, face->GetFace());
+ }
+
+ RefPtr<ScaledFontFontconfig> scaledFont =
+ new ScaledFontFontconfig(std::move(face), instanceData, this, aSize);
+
+ return scaledFont.forget();
+}
+
+already_AddRefed<ScaledFont> UnscaledFontFontconfig::CreateScaledFontFromWRFont(
+ Float aGlyphSize, const wr::FontInstanceOptions* aOptions,
+ const wr::FontInstancePlatformOptions* aPlatformOptions,
+ const FontVariation* aVariations, uint32_t aNumVariations) {
+ ScaledFontFontconfig::InstanceData instanceData(aOptions, aPlatformOptions);
+ return CreateScaledFont(aGlyphSize, reinterpret_cast<uint8_t*>(&instanceData),
+ sizeof(instanceData), aVariations, aNumVariations);
+}
+
+bool ScaledFontFontconfig::HasVariationSettings() {
+ // Check if the FT face has been cloned.
+ return mFace &&
+ mFace->GetFace()->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS &&
+ mFace != static_cast<UnscaledFontFontconfig*>(mUnscaledFont.get())
+ ->GetFace();
+}
+
+already_AddRefed<UnscaledFont> UnscaledFontFontconfig::CreateFromFontDescriptor(
+ const uint8_t* aData, uint32_t aDataLength, uint32_t aIndex) {
+ if (aDataLength == 0) {
+ gfxWarning() << "Fontconfig font descriptor is truncated.";
+ return nullptr;
+ }
+ const char* path = reinterpret_cast<const char*>(aData);
+ RefPtr<UnscaledFont> unscaledFont =
+ new UnscaledFontFontconfig(std::string(path, aDataLength), aIndex);
+ return unscaledFont.forget();
+}
+
+} // namespace mozilla::gfx